├── .coveragerc
├── .travis.yml
├── CHANGELOG.rst
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.rst
├── ISSUE_TEMPLATE.md
├── LICENSE
├── MANIFEST.in
├── PyPI CHECKLIST.txt
├── README.rst
├── async_v20
    ├── .gitignore
    ├── __init__.py
    ├── client.py
    ├── definitions
    │   ├── __init__.py
    │   ├── attributes.py
    │   ├── base.py
    │   ├── health_types.py
    │   ├── helpers.py
    │   ├── primitives.py
    │   └── types.py
    ├── endpoints
    │   ├── __init__.py
    │   ├── account.py
    │   ├── annotations.py
    │   ├── base.py
    │   ├── health.py
    │   ├── instrument.py
    │   ├── order.py
    │   ├── other_responses.py
    │   ├── position.py
    │   ├── pricing.py
    │   ├── trade.py
    │   ├── transaction.py
    │   └── user.py
    ├── exceptions.py
    └── interface
    │   ├── __init__.py
    │   ├── account.py
    │   ├── decorators.py
    │   ├── health.py
    │   ├── helpers.py
    │   ├── instrument.py
    │   ├── order.py
    │   ├── parser.py
    │   ├── position.py
    │   ├── pricing.py
    │   ├── response.py
    │   ├── rest.py
    │   ├── trade.py
    │   ├── transaction.py
    │   └── user.py
├── bin
    ├── __init__.py
    ├── account.py
    ├── account_changes.py
    ├── candle_data.py
    ├── candles.py
    ├── check_api_methods.py
    ├── concurrent_example.py
    ├── data_download_tool.py
    ├── initialization.py
    ├── passing_arguments.py
    ├── place_order.py
    ├── poll_account.py
    ├── preload.py
    ├── stream_prices.py
    └── stream_transactions.py
├── doc
    ├── Makefile
    ├── build
    │   ├── doctrees
    │   │   ├── api.doctree
    │   │   ├── environment.pickle
    │   │   ├── glossary.doctree
    │   │   └── index.doctree
    │   └── html
    │   │   ├── .buildinfo
    │   │   ├── _modules
    │   │       └── index.html
    │   │   ├── _sources
    │   │       ├── api.rst.txt
    │   │       ├── glossary.rst.txt
    │   │       └── index.rst.txt
    │   │   ├── _static
    │   │       ├── ajax-loader.gif
    │   │       ├── basic.css
    │   │       ├── comment-bright.png
    │   │       ├── comment-close.png
    │   │       ├── comment.png
    │   │       ├── doctools.js
    │   │       ├── down-pressed.png
    │   │       ├── down.png
    │   │       ├── file.png
    │   │       ├── jquery-3.1.0.js
    │   │       ├── jquery.js
    │   │       ├── minus.png
    │   │       ├── plus.png
    │   │       ├── pygments.css
    │   │       ├── searchtools.js
    │   │       ├── underscore-1.3.1.js
    │   │       ├── underscore.js
    │   │       ├── up-pressed.png
    │   │       ├── up.png
    │   │       └── websupport.js
    │   │   ├── api.html
    │   │   ├── genindex.html
    │   │   ├── glossary.html
    │   │   ├── index.html
    │   │   ├── objects.inv
    │   │   ├── search.html
    │   │   └── searchindex.js
    ├── make.bat
    └── source
    │   ├── _static
    │       └── async_v20-icon-128x128.png
    │   ├── annotations.rst
    │   ├── api.rst
    │   ├── best_practices.rst
    │   ├── beyond_getting_started.rst
    │   ├── conf.py
    │   ├── datetimes.rst
    │   ├── definitions
    │       ├── account.rst
    │       ├── instrument.rst
    │       ├── order.rst
    │       ├── positions.rst
    │       ├── pricing.rst
    │       ├── trade.rst
    │       └── transaction.rst
    │   ├── environment_variables.rst
    │   ├── exceptions.rst
    │   ├── getting_started.rst
    │   ├── glossary.rst
    │   ├── health.rst
    │   ├── index.rst
    │   ├── logging.rst
    │   ├── order_request_formatting.rst
    │   ├── particularly_pertinent.rst
    │   ├── primitives.rst
    │   ├── response.rst
    │   ├── traps.rst
    │   └── types.rst
├── perftests
    ├── __init__.py
    ├── account_changes_json.py
    ├── creating_arrays.py
    ├── creating_dataframe.py
    ├── creating_orders.py
    ├── helpers.py
    ├── rest_implementation.py
    └── server.py
├── readthedocs.yml
├── requirements.txt
├── setup.cfg
├── setup.py
└── tests
    ├── __init__.py
    ├── data
        ├── __init__.py
        └── json_data.py
    ├── fixtures
        ├── __init__.py
        ├── client.py
        ├── routes.py
        ├── server.py
        └── static.py
    ├── test_client.py
    ├── test_definitions
        ├── __init__.py
        ├── helpers.py
        ├── test_attributes.py
        ├── test_base.py
        ├── test_health_types.py
        ├── test_helpers.py
        ├── test_primitives.py
        └── test_types.py
    ├── test_endpoints
        ├── __init__.py
        └── test_annotations.py
    ├── test_interface
        ├── __init__.py
        ├── helpers.py
        ├── test_api_methods.py
        ├── test_docstrings.py
        ├── test_helpers.py
        ├── test_parser.py
        └── test_response.py
    ├── test_server_fixture.py
    └── test_type_creation
        ├── __init__.py
        └── test_object_construction.py


/.coveragerc:
--------------------------------------------------------------------------------
1 | [run]
2 | source=async_v20


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: python
 2 | os:
 3 |   - linux
 4 | python:
 5 |   - 3.6
 6 |   - 3.7-dev
 7 | install:
 8 |   - pip install -r requirements.txt
 9 | script:
10 |   - pytest --cov
11 | after_success:
12 |   - codecov
13 | env:
14 |   - OANDA_TOKEN='test_environ_token'


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
 6 | 
 7 | ## Our Standards
 8 | 
 9 | Examples of behavior that contributes to creating a positive environment include:
10 | 
11 | * Using welcoming and inclusive language
12 | * Being respectful of differing viewpoints and experiences
13 | * Gracefully accepting constructive criticism
14 | * Focusing on what is best for the community
15 | * Showing empathy towards other community members
16 | 
17 | Examples of unacceptable behavior by participants include:
18 | 
19 | * The use of sexualized language or imagery and unwelcome sexual attention or advances
20 | * Trolling, insulting/derogatory comments, and personal or political attacks
21 | * Public or private harassment
22 | * Publishing others' private information, such as a physical or electronic address, without explicit permission
23 | * Other conduct which could reasonably be considered inappropriate in a professional setting
24 | 
25 | ## Our Responsibilities
26 | 
27 | Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
28 | 
29 | Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
30 | 
31 | ## Scope
32 | 
33 | This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
34 | 
35 | ## Enforcement
36 | 
37 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at james.peter.schinner@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
38 | 
39 | Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
40 | 
41 | ## Attribution
42 | 
43 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
44 | 
45 | [homepage]: http://contributor-covenant.org
46 | [version]: http://contributor-covenant.org/version/1/4/
47 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.rst:
--------------------------------------------------------------------------------
  1 | 
  2 | Guide lines adapted from `aiohttp <http://aiohttp.readthedocs.io/en/stable/>`_
  3 | 
  4 | Contributing
  5 | ============
  6 | 
  7 | How to contribute
  8 | 
  9 | Imposter syndrome disclaimer: I want your help. No really, I do.
 10 | 
 11 | There might be a little voice inside that tells you you're not ready; that you need to do one more tutorial,
 12 | or learn another framework, or write a few more blog posts before you can help me with this project.
 13 | 
 14 | I assure you, that's not the case.
 15 | 
 16 | This project has some clear Contribution Guidelines and expectations that you can read here (link).
 17 | 
 18 | The contribution guidelines outline the process that you'll need to follow to get a patch merged.
 19 | By making expectations and process explicit, I hope it will make it easier for you to contribute.
 20 | 
 21 | And you don't just have to write code. You can help out by writing documentation, tests,
 22 | or even by giving feedback about this work.
 23 | (And yes, that includes giving feedback about the contribution guidelines.)
 24 | 
 25 | Thank you for contributing!
 26 | 
 27 | Code Evaluation
 28 | _______________
 29 | 
 30 | async_v20 aims to lower the barrier of entry to algorithmically trade on the FOREX market.
 31 | 
 32 | Features such as:
 33 |     - Correct signature for all API methods
 34 |     - Converting objects to *pandas*. **Series**
 35 | 
 36 | Are examples of features provided with this goal in mind.
 37 | 
 38 | Pull Requests that lessen the technical burden on users will be highly regarded
 39 | 
 40 | 
 41 | Instructions for contributors
 42 | -----------------------------
 43 | 
 44 | 
 45 | In order to make a clone of the GitHub_ repo: open the link and press the
 46 | "Fork" button on the upper-right menu of the web page.
 47 | 
 48 | Workflow:
 49 | 
 50 |   1. Clone the GitHub_ repo
 51 | 
 52 |   2. Make a change
 53 | 
 54 |   3. Make sure all tests passed
 55 | 
 56 |   4. Add a file into ``CHANGES`` folder (`Changelog update`_).
 57 | 
 58 |   5. Commit changes to own aiohttp clone
 59 | 
 60 |   6. Make pull request from github page for your clone against master branch
 61 | 
 62 |   .. note::
 63 |      If your PR has long history or many commits
 64 |      please rebase it from main repo before creating PR.
 65 | 
 66 | 
 67 | Tests coverage
 68 | --------------
 69 | 
 70 | Please add a test corresponding to any new features
 71 | 
 72 | async_v20 uses **pytest**
 73 | 
 74 | Install the test runner first:
 75 | 
 76 | .. code-block:: shell
 77 | 
 78 |    $ pip install pytest
 79 |    $ pip install pytest-asyncio
 80 | 
 81 | Test your changes with
 82 | 
 83 | .. code-block:: shell
 84 | 
 85 |    $ pytest
 86 | 
 87 | 
 88 | Documentation
 89 | -------------
 90 | 
 91 | documentation improvements are wanted!
 92 | 
 93 | Before making a Pull Request with documentation changes.
 94 | 
 95 | from async_v20 root directory run:
 96 | 
 97 | .. code-block:: shell
 98 | 
 99 |    $ make clean
100 |    $ make html
101 | 
102 | Run the python's in built http server from async_v20's root directory
103 | 
104 | .. code-block:: shell
105 | 
106 |    $ python -m http.server
107 | 
108 | Navigate to:
109 | 
110 | http://localhost:8000/
111 | 
112 | And check the changes
113 | 
114 | Changelog update
115 | ----------------
116 | 
117 | Please add changes to ``CHANGELOG.txt``
118 | 
119 | 
120 | The End
121 | -------
122 | 
123 | After finishing all steps make a GitHub_ Pull Request, thanks.
124 | 
125 | 
126 | .. _GitHub: https://github.com/jamespeterschinner/async_v20
127 | 
128 | 


--------------------------------------------------------------------------------
/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | **Description of issue:**
 2 | 
 3 | **Your environment(os, python, packages)**
 4 | 
 5 | **Expected behaviour:**
 6 | 
 7 | **Actual behaviour:**
 8 | 
 9 | **Complete self contained example of issue:**
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) [2017] [James Peter Schinner]
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
1 | include README.rst
2 | include CHANGELOG.rst


--------------------------------------------------------------------------------
/PyPI CHECKLIST.txt:
--------------------------------------------------------------------------------
1 | - Versions match in setup.py and client.py and conf.py
2 | - CHANGELOG updated
3 | - Tests pass
4 | - latest Version on gitHub
5 | - Build, and Docs passing
6 | - all bin examples work
7 | - Upload to PyPI TEST. Does it look good?


--------------------------------------------------------------------------------
/async_v20/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | 


--------------------------------------------------------------------------------
/async_v20/__init__.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | from async_v20.client import OandaClient
 4 | from async_v20.client import __version__
 5 | from async_v20.definitions import *
 6 | from async_v20.endpoints.annotations import *
 7 | 
 8 | logging.getLogger(__name__).addHandler(logging.NullHandler())
 9 | 
10 | __version__ = __version__
11 | 


--------------------------------------------------------------------------------
/async_v20/definitions/__init__.py:
--------------------------------------------------------------------------------
1 | from .primitives import *
2 | from .types import *
3 | 
4 | __all__ = (types.__all__ + primitives.__all__)
5 | 


--------------------------------------------------------------------------------
/async_v20/definitions/health_types.py:
--------------------------------------------------------------------------------
 1 | from .base import Model, Array
 2 | 
 3 | 
 4 | class ServiceList(Model):
 5 |     """A collection of related services
 6 |     """
 7 | 
 8 |     def __init__(self, id: str, name: str, description: str, url: str):
 9 |         Model.__init__(**locals())
10 | 
11 | 
12 | class ArrayServiceList(Array, contains=ServiceList):
13 |     pass
14 | 
15 | 
16 | class Status(Model):
17 |     """The current event of a status"""
18 | 
19 |     def __init__(self, id: str, name: str, description: str, url: str,
20 |                 level: str, image: str, default: bool):
21 |         Model.__init__(**locals())
22 | 
23 | 
24 | class ArrayStatus(Array, contains=Status):
25 |     pass
26 | 
27 | 
28 | class Event(Model):
29 |     """Anything Interesting that has happened to a Service"""
30 | 
31 |     def __init__(self, sid: str, message: str, timestamp: str,
32 |                 url: str, status: Status, informational: bool):
33 |         Model.__init__(**locals())
34 | 
35 | 
36 | class ArrayEvent(Array, contains=Event):
37 |     pass
38 | 
39 | 
40 | class Service(Model):
41 |     """A log of all events that have occurred in the past.
42 |     The current state of a service is represented by the current status of the service."""
43 | 
44 |     def __init__(self, id: str, name: str, description: str,
45 |                 list: ServiceList, current_event: Event, url: str):
46 |         Model.__init__(**locals())
47 | 
48 | 
49 | class ArrayService(Array, contains=Service):
50 |     pass
51 | 
52 | class Image(Model):
53 |     """An Image to be displayed to the end user.
54 |     """
55 | 
56 |     def __init__(self, name: str, icon_set: str, url: str):
57 |         Model.__init__(**locals())
58 | 
59 | 
60 | class ArrayImage(Array, contains=Image):
61 |     pass
62 | 


--------------------------------------------------------------------------------
/async_v20/definitions/helpers.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | import warnings
 3 | from inspect import _empty
 4 | from itertools import starmap, chain
 5 | 
 6 | from .attributes import instance_attributes
 7 | from ..exceptions import IncompatibleValue
 8 | from ..exceptions import InvalidValue
 9 | from ..exceptions import UnknownKeywordArgument
10 | 
11 | logger = logging.getLogger(__name__)
12 | 
13 | sentinel = object()
14 | 
15 | 
16 | def check_conflicting_arguments(self, kwargs, preset_values):
17 |     for argument, preset_value in preset_values.items():
18 |         value = kwargs.pop(argument, None)
19 |         if value is not None and value != preset_value:
20 |             msg = f'CLASS {self.__class__.__name__}.{argument}' \
21 |                   f' MUST == {preset_value} NOT {value}'
22 |             logger.error(msg)
23 |             raise IncompatibleValue(msg)
24 | 
25 | 
26 | def json_to_instance_attributes(self, kwargs, template):
27 |     """Convert CamelCase keyword arguments to snake_case. Also
28 |     validate corresponding snake_case keyword argument is a valid
29 |     argument for the class being initialized.
30 |     """
31 | 
32 |     for key, value in kwargs.items():
33 |         try:
34 |             attr = instance_attributes[key]
35 |             assert attr in template
36 |             yield attr, value
37 |         except (KeyError, AssertionError):
38 |             possible_arguments = ', '.join(attr for attr in template)
39 |             msg = f'`{key}` with value `{value}` supplied to {self.__class__.__qualname__} \n' \
40 |                   f'Possible arguments include: {possible_arguments}'
41 |             logger.error(msg)
42 |             warnings.warn(msg, UnknownKeywordArgument)
43 | 
44 | 
45 | def domain_check(value, example=None, possible_values=None):
46 |     if example:
47 |         if not len(str(example)) == len(str(value)):
48 |             msg = f'{value} does not match length of example {example}'
49 |             logger.error(msg)
50 |             raise InvalidValue(msg)
51 | 
52 |     if possible_values:
53 |         if not value in possible_values:
54 |             possible_values = ', '.join(possible_values)
55 |             msg = f'{value} must be in {possible_values}. Possible values are {possible_values}'
56 |             logger.error(msg)
57 |             raise InvalidValue(msg)
58 | 
59 |     return True
60 | 
61 | 
62 | def flatten_dict(dictionary, delimiter='_'):
63 |     """Flatten a nested dictionary structure"""
64 | 
65 |     def unpack(parent_key, parent_value):
66 |         """Unpack one level of nesting in a dictionary"""
67 |         try:
68 |             items = parent_value.items()
69 |         except AttributeError:
70 |             # parent_value was not a dict, no need to flatten
71 |             yield (parent_key, parent_value)
72 |         else:
73 |             for key, value in items:
74 |                 yield (parent_key + delimiter + key, value)
75 | 
76 |     while True:
77 |         # Keep unpacking the dictionary until all value's are not dictionary's
78 |         dictionary = dict(chain.from_iterable(starmap(unpack, dictionary.items())))
79 |         if not any(isinstance(value, dict) for value in dictionary.values()):
80 |             break
81 | 
82 |     return dictionary
83 | 
84 | 
85 | def create_doc_signature(obj, sig):
86 |     names = list(sig.parameters.keys())
87 |     annotations = list(
88 |         map(lambda x: '' if x.annotation == _empty else ': ' + x.annotation.__name__, sig.parameters.values()))
89 |     defaults = list(map(lambda x: '' if x.default == _empty else '=' + str(x.default)
90 |                         if not x.default is sentinel else '= sentinel ', sig.parameters.values()))
91 |     arguments = ', '.join(''.join(argument) for argument in zip(names, annotations, defaults))
92 |     return f'{obj.__name__}({arguments})\n{obj.__doc__}'
93 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/__init__.py:
--------------------------------------------------------------------------------
 1 | from .account import *
 2 | from .instrument import *
 3 | from .order import *
 4 | from .position import *
 5 | from .pricing import *
 6 | from .trade import *
 7 | from .transaction import *
 8 | from .user import *
 9 | 
10 | __all__ = (account.__all__ +
11 |            instrument.__all__ +
12 |            order.__all__ +
13 |            pricing.__all__ +
14 |            trade.__all__ +
15 |            transaction.__all__ +
16 |            user.__all__)
17 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/account.py:
--------------------------------------------------------------------------------
  1 | from .annotations import Alias
  2 | from .annotations import Authorization
  3 | from .annotations import Instruments
  4 | from .annotations import SinceTransactionID
  5 | from .base import EndPoint, HEADER, PATH, QUERY
  6 | from ..definitions.primitives import *
  7 | from ..definitions.types import *
  8 | 
  9 | __all__ = ['GETAccounts', 'GETAccountID', 'GETAccountIDSummary', 'GETAccountIDInstruments',
 10 |            'PATCHAccountIDConfiguration', 'GETAccountIDChanges']
 11 | 
 12 | 
 13 | class GETAccounts(EndPoint):
 14 |     # the HTTP verb to use for this endpoint
 15 |     method = 'GET'
 16 | 
 17 |     # path to endpoint
 18 |     path = ('/v3/accounts',)
 19 | 
 20 |     # description of endpoint
 21 |     description = 'Get a list of all Accounts authorized for the provided token.'
 22 | 
 23 |     # parameters required to send to endpoint
 24 |     parameters = {Authorization: (HEADER, 'Authorization')}
 25 | 
 26 |     # valid responses
 27 |     responses = {200: {'accounts': ArrayAccountProperties}}
 28 | 
 29 |     # error msgs'
 30 |     error = (401, 405)
 31 | 
 32 | 
 33 | class GETAccountID(EndPoint):
 34 |     # the HTTP verb to use for this endpoint
 35 |     method = 'GET'
 36 | 
 37 |     # path to endpoint
 38 |     path = ('/v3/accounts/', AccountID)
 39 | 
 40 |     # description of endpoint
 41 |     description = 'Get the full details for a single Account that a client has access to. ' \
 42 |                   'Full pending Order, open Trade and open Position representations are provided.'
 43 | 
 44 |     # parameters required to send to endpoint
 45 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
 46 |                   AccountID: (PATH, 'accountID')}
 47 |     # valid responses
 48 |     responses = {200: {'account': Account, 'lastTransactionID': TransactionID}}
 49 | 
 50 |     # error msgs'
 51 |     error = (400, 401, 405)
 52 | 
 53 | 
 54 | class GETAccountIDSummary(EndPoint):
 55 |     # the HTTP verb to use for this endpoint
 56 |     method = 'GET'
 57 | 
 58 |     # path to endpoint
 59 |     path = ('/v3/accounts/', AccountID, '/summary')
 60 | 
 61 |     # description of endpoint
 62 |     description = 'Get a summary for a single Account that a client has access to.'
 63 | 
 64 |     # parameters required to send to endpoint
 65 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
 66 |                   AccountID: (PATH, 'accountID')}
 67 | 
 68 |     # valid responses
 69 |     responses = {200: {'account': AccountSummary, 'lastTransactionID': TransactionID}}
 70 | 
 71 |     # error msgs'
 72 |     error = (400, 401, 405)
 73 | 
 74 | 
 75 | class GETAccountIDInstruments(EndPoint):
 76 |     # the HTTP verb to use for this endpoint
 77 |     method = 'GET'
 78 | 
 79 |     # path to endpoint
 80 |     path = ('/v3/accounts/', AccountID, '/instruments')
 81 | 
 82 |     # description of endpoint
 83 |     description = 'Get the list of tradeable instruments for the given Account.' \
 84 |                   'The list of tradeable instruments is dependent on the regulatory ' \
 85 |                   'division that the Account is located in, thus should be the same for all ' \
 86 |                   'Accounts owned by a single user.'
 87 | 
 88 |     # parameters required to send to endpoint
 89 |     parameters = {Authorization: (HEADER, 'Authorization'), AccountID: (PATH, 'accountID'),
 90 |                   Instruments: (QUERY, 'instruments')}
 91 | 
 92 |     # valid responses
 93 |     responses = {200: {'instruments': ArrayInstrument, 'lastTransactionID': TransactionID}}
 94 | 
 95 |     # error msgs'
 96 |     error = (400, 401, 405)
 97 | 
 98 | 
 99 | class PATCHAccountIDConfiguration(EndPoint):
100 |     # the HTTP verb to use for this endpoint
101 |     method = 'PATCH'
102 | 
103 |     # path to endpoint
104 |     path = ('/v3/accounts/', AccountID, '/configuration')
105 | 
106 |     # description of endpoint
107 |     description = 'Set the client-configurable portions of an Account.'
108 | 
109 |     # parameters required to send to endpoint
110 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
111 |                   AccountID: (PATH, 'accountID')}
112 | 
113 |     # valid responses
114 |     responses = {200: {'clientConfigureTransaction': ClientConfigureTransaction, 'lastTransactionID': TransactionID},
115 |                  400: {'clientConfigureRejectTransaction': ClientConfigureRejectTransaction,
116 |                        'lastTransactionID': TransactionID, 'errorCode': str, 'errorMessage': str},
117 |                  403: {'clientConfigureRejectTransaction': ClientConfigureRejectTransaction,
118 |                        'lastTransactionID': TransactionID, 'errorCode': str, 'errorMessage': str}}
119 | 
120 |     # error msgs'
121 |     error = (401, 404, 405)
122 | 
123 |     # json schema representation
124 |     request_schema = {Alias: 'alias', DecimalNumber: 'marginRate'}
125 | 
126 | 
127 | class GETAccountIDChanges(EndPoint):
128 |     # the HTTP verb to use for this endpoint
129 |     method = 'GET'
130 | 
131 |     # path to endpoint
132 |     path = ('/v3/accounts/', AccountID, '/changes')
133 |     # description of endpoint
134 |     description = 'Endpoint used to poll an Account for its current state and changes since a specified TransactionID.'
135 | 
136 |     # parameters required to send to endpoint
137 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
138 |                   AccountID: (PATH, 'accountID'), SinceTransactionID: (QUERY, 'sinceTransactionID')}
139 | 
140 |     # valid responses
141 |     responses = {200: {'changes': AccountChanges, 'state': AccountChangesState, 'lastTransactionID': TransactionID}}
142 | 
143 |     # error msgs'
144 |     error = (401, 404, 405, 416)
145 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/base.py:
--------------------------------------------------------------------------------
 1 | HEADER = 'header'
 2 | PATH = 'path'
 3 | QUERY = 'query'
 4 | HEALTH = 'HEALTH'
 5 | 
 6 | class EndPoint(object):
 7 |     """Base object representation of an endpoint"""
 8 | 
 9 |     # Default host to use unless otherwise specified by a derived class
10 |     host = 'REST'
11 | 
12 |     # Path needs to be a Path object
13 |     path = ()
14 | 
15 |     # the HTTP verb to use for this endpoint
16 |     method = ''
17 | 
18 |     # description of endpoint
19 |     description = ''
20 | 
21 |     # parameters required to send to endpoint
22 |     parameters = {}
23 | 
24 |     # valid responses
25 |     responses = {}
26 | 
27 |     # error msgs'
28 |     error = ()
29 | 
30 |     # json format the data body as per the response_schema below
31 |     request_schema = {}
32 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/health.py:
--------------------------------------------------------------------------------
  1 | from .annotations import ServiceID, ServiceListID, Start, End, EventSid, StatusID
  2 | from ..definitions.health_types import *
  3 | from ..endpoints.base import EndPoint, PATH, QUERY, HEALTH
  4 | 
  5 | 
  6 | class GETServices(EndPoint):
  7 |     host = HEALTH
  8 | 
  9 |     # the HTTP verb to use for this endpoint
 10 |     method = 'GET'
 11 | 
 12 |     # path to endpoint
 13 |     path = ('/api/v1/services',)
 14 | 
 15 |     # valid responses
 16 |     responses = {200: {'services': ArrayService}}
 17 | 
 18 |     # error msgs'
 19 |     error = (404,)
 20 | 
 21 | 
 22 | class GETService(EndPoint):
 23 |     host = HEALTH
 24 | 
 25 |     # the HTTP verb to use for this endpoint
 26 |     method = 'GET'
 27 | 
 28 |     # path to endpoint
 29 |     path = ('/api/v1/services/', ServiceID)
 30 | 
 31 |     parameters = {ServiceID: (PATH, 'service-id')}
 32 | 
 33 |     # valid responses
 34 |     responses = {200: Service}
 35 | 
 36 |     # error msgs'
 37 |     error = (404,)
 38 | 
 39 | class GETServiceLists(EndPoint):
 40 |     host = HEALTH
 41 | 
 42 |     # the HTTP verb to use for this endpoint
 43 |     method = 'GET'
 44 | 
 45 |     # path to endpoint
 46 |     path = ('/api/v1/service-lists',)
 47 | 
 48 |     # valid responses
 49 |     responses = {200: {'lists': ArrayServiceList}}
 50 | 
 51 |     # error msgs'
 52 |     error = (404,)
 53 | 
 54 | class GETServiceList(EndPoint):
 55 |     host = HEALTH
 56 | 
 57 |     # the HTTP verb to use for this endpoint
 58 |     method = 'GET'
 59 | 
 60 |     # path to endpoint
 61 |     path = ('/api/v1/service-lists/', ServiceListID)
 62 | 
 63 |     parameters = {ServiceListID: (PATH, 'service_list_id')}
 64 | 
 65 |     # valid responses
 66 |     responses = {200: {'lists': ServiceList}}
 67 | 
 68 |     # error msgs'
 69 |     error = (404,)
 70 | 
 71 | class GETEvents(EndPoint):
 72 |     host = HEALTH
 73 | 
 74 |     # the HTTP verb to use for this endpoint
 75 |     method = 'GET'
 76 | 
 77 |     # path to endpoint
 78 |     path = ('/api/v1/services/', ServiceID, '/events')
 79 | 
 80 |     # parameters required to send to endpoint
 81 |     parameters = {ServiceID: (PATH, 'service-id'), Start: (QUERY, 'start'), End: (QUERY, 'end')}
 82 | 
 83 |     # valid responses
 84 |     responses = {200: {'events': ArrayEvent}}
 85 | 
 86 |     # error msgs'
 87 |     error = (404,)
 88 | 
 89 | class GETCurrentEvent(EndPoint):
 90 |     host = HEALTH
 91 | 
 92 |     # the HTTP verb to use for this endpoint
 93 |     method = 'GET'
 94 | 
 95 |     # path to endpoint
 96 |     path = ('/api/v1/services/', ServiceID, '/events/current')
 97 | 
 98 |     # parameters required to send to endpoint
 99 |     parameters = {ServiceID: (PATH, 'service-id')}
100 | 
101 |     # valid responses
102 |     responses = {200: Event}
103 | 
104 |     # error msgs'
105 |     error = (404,)
106 | 
107 | class GETEvent(EndPoint):
108 |     host = HEALTH
109 | 
110 |     # the HTTP verb to use for this endpoint
111 |     method = 'GET'
112 | 
113 |     # path to endpoint
114 |     path = ('/api/v1/services/', ServiceID, '/events/', EventSid)
115 | 
116 |     # parameters required to send to endpoint
117 |     parameters = {ServiceID: (PATH, 'service-id'),
118 |                   EventSid: (PATH, 'event-sid')}
119 | 
120 |     # valid responses
121 |     responses = {200: Event}
122 | 
123 |     # error msgs'
124 |     error = (404,)
125 | 
126 | class GETStatuses(EndPoint):
127 |     host = HEALTH
128 | 
129 |     # the HTTP verb to use for this endpoint
130 |     method = 'GET'
131 | 
132 |     # path to endpoint
133 |     path = ('/api/v1/statuses',)
134 | 
135 |     # valid responses
136 |     responses = {200: {'statuses': ArrayStatus}}
137 | 
138 |     # error msgs'
139 |     error = (404,)
140 | 
141 | class GETStatus(EndPoint):
142 |     host = HEALTH
143 | 
144 |     # the HTTP verb to use for this endpoint
145 |     method = 'GET'
146 | 
147 |     # path to endpoint
148 |     path = ('/api/v1/statuses/', StatusID)
149 | 
150 |     # parameters required to send to endpoint
151 |     parameters = {StatusID: (PATH, 'status-id')}
152 | 
153 |     # valid responses
154 |     responses = {200: Status}
155 | 
156 |     # error msgs'
157 |     error = (404,)
158 | 
159 | class GETImages(EndPoint):
160 |     host = HEALTH
161 | 
162 |     # the HTTP verb to use for this endpoint
163 |     method = 'GET'
164 | 
165 |     # path to endpoint
166 |     path = ('/api/v1/status-images',)
167 | 
168 |     # valid responses
169 |     responses = {200: {'images': ArrayImage}}
170 | 
171 |     # error msgs'
172 |     error = (404,)


--------------------------------------------------------------------------------
/async_v20/endpoints/instrument.py:
--------------------------------------------------------------------------------
 1 | from .annotations import *
 2 | from .base import EndPoint, HEADER, PATH, QUERY
 3 | from ..definitions.primitives import *
 4 | from ..definitions.types import *
 5 | 
 6 | __all__ = ['GETInstrumentsCandles', 'GETInstrumentOrderBook', 'GETInstrumentsPositionBook']
 7 | 
 8 | 
 9 | class GETInstrumentsCandles(EndPoint):
10 |     # the HTTP verb to use for this endpoint
11 |     method = 'GET'
12 | 
13 |     # path to endpoint
14 |     path = ('/v3/instruments/', InstrumentName, '/candles')
15 | 
16 |     # description of endpoint
17 |     description = 'Fetch candlestick data for an instrument.'
18 | 
19 |     # parameters required to send to endpoint
20 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
21 |                   InstrumentName: (PATH, 'instrument'), PriceComponent: (QUERY, 'price'),
22 |                   CandlestickGranularity: (QUERY, 'granularity'), Count: (QUERY, 'count'), FromTime: (QUERY, 'from'),
23 |                   ToTime: (QUERY, 'to'), Smooth: (QUERY, 'smooth'), IncludeFirstQuery: (QUERY, 'includeFirst'),
24 |                   DailyAlignment: (QUERY, 'dailyAlignment'), AlignmentTimezone: (QUERY, 'alignmentTimezone'),
25 |                   WeeklyAlignment: (QUERY, 'weeklyAlignment')}
26 | 
27 |     # valid responses
28 |     responses = {
29 |         200: {'instrument': InstrumentName, 'granularity': CandlestickGranularity, 'candles': ArrayCandlestick}}
30 | 
31 |     # error msgs'
32 |     error = (400, 401, 404, 405)
33 | 
34 | 
35 | class GETInstrumentOrderBook(EndPoint):
36 |     # the HTTP verb to use for this endpoint
37 |     method = 'GET'
38 | 
39 |     # path to endpoint
40 |     path = ('/v3/instruments/', InstrumentName, '/orderBook')
41 | 
42 |     # description of endpoint
43 |     description = 'Fetch a gzip compressed order book for an instrument.'
44 | 
45 |     # parameters required to send to endpoint
46 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
47 |                   InstrumentName: (PATH, 'instrument'), DateTime: (QUERY, 'time')}
48 | 
49 |     # valid responses
50 |     responses = {200: {'orderBook': OrderBook}}
51 | 
52 |     # error msgs'
53 |     error = (400, 401, 404, 405)
54 | 
55 | 
56 | class GETInstrumentsPositionBook(EndPoint):
57 |     # the HTTP verb to use for this endpoint
58 |     method = 'GET'
59 | 
60 |     # path to endpoint
61 |     path = ('/v3/instruments/', InstrumentName, '/positionBook')
62 | 
63 |     # description of endpoint
64 |     description = 'Fetch a gzip compressed position book for an instrument.'
65 | 
66 |     # parameters required to send to endpoint
67 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
68 |                   InstrumentName: (PATH, 'instrument'), DateTime: (QUERY, 'time')}
69 | 
70 |     # valid responses
71 |     responses = {200: {'positionBook': PositionBook}}
72 | 
73 |     # error msgs'
74 |     error = (400, 401, 404, 405)
75 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/other_responses.py:
--------------------------------------------------------------------------------
 1 | string = str
 2 | error_response = {'errorCode': string, 'errorMessage': string}
 3 | other_responses = {
 4 |     # A "400 Bad Request" response may be returned from the v20 REST API when the client has
 5 |     # provided invalid data to be processed.
 6 |     400: error_response,
 7 |     # A "401 Unauthorized" response may be returned from the v20 REST API when the endpoint being
 8 |     # accessed requires the client to be authenticated however the authentication token is invalid
 9 |     # or has not been provided.
10 |     401: error_response,
11 |     # A "403 Forbidden" response may be returned from the v20 REST API when the client has provided
12 |     # a token that does not authorize them to perform the action implemented by the API endpoint.
13 |     403: error_response,
14 |     # A "404 Not Found" response may be returned from the v20 REST API when the client is attempting
15 |     # to refer to an entity (Account, Trade, Order, Position, etc.) that does not exist.
16 |     404: error_response,
17 |     # A "405 Method Not Allowed" response may be returned from the v20 REST API when the client is
18 |     # attempting to access an API endpoint with an HTTP method that is not supported.
19 |     405: error_response,
20 |     # A "416 Range Not Satisfiable" response may be returned from the v20 REST API when the client
21 |     # has specified a range (time range or Transaction range) that is invalid or cannot be processed.
22 |     416: error_response,
23 |     # Excess requests will receive HTTP 429 error.
24 |     # This restriction is applied against the requesting IP address.
25 |     429: error_response
26 | }
27 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/position.py:
--------------------------------------------------------------------------------
  1 | from .annotations import *
  2 | from .base import EndPoint, HEADER, PATH
  3 | from ..definitions.primitives import *
  4 | from ..definitions.types import *
  5 | 
  6 | __all__ = ['GETPositions', 'GETOpenPositions', 'GETPositionsInstrument', 'PUTPositionsInstrumentClose']
  7 | 
  8 | 
  9 | class GETPositions(EndPoint):
 10 |     # the HTTP verb to use for this endpoint
 11 |     method = 'GET'
 12 | 
 13 |     # path to endpoint
 14 |     path = ('/v3/accounts/', AccountID, '/positions')
 15 | 
 16 |     # description of endpoint
 17 |     description = 'List all Positions for an Account. The Positions returned are for every ' \
 18 |                   'instrument that has had a position during the lifetime of an the Account.'
 19 | 
 20 |     # parameters required to send to endpoint
 21 |     parameters = {Authorization: (HEADER, 'Authorization'), AccountID: (PATH, 'accountID')}
 22 | 
 23 |     # valid responses
 24 |     responses = {200: {'positions': ArrayPosition, 'lastTransactionID': TransactionID}}
 25 | 
 26 |     # error msgs'
 27 |     error = (401, 404, 405)
 28 | 
 29 | 
 30 | class GETOpenPositions(EndPoint):
 31 |     # the HTTP verb to use for this endpoint
 32 |     method = 'GET'
 33 | 
 34 |     # path to endpoint
 35 |     path = ('/v3/accounts/', AccountID, '/openPositions')
 36 | 
 37 |     # description of endpoint
 38 |     description = 'List all open Positions for an Account. An open Position is a ' \
 39 |                   'Position in an Account that currently has a Trade opened for it.'
 40 | 
 41 |     # parameters required to send to endpoint
 42 |     parameters = {Authorization: (HEADER, 'Authorization'), AccountID: (PATH, 'accountID')}
 43 | 
 44 |     # valid responses
 45 |     responses = {200: {'positions': ArrayPosition, 'lastTransactionID': TransactionID}}
 46 | 
 47 |     # error msgs'
 48 |     error = (401, 404, 405)
 49 | 
 50 | 
 51 | class GETPositionsInstrument(EndPoint):
 52 |     # the HTTP verb to use for this endpoint
 53 |     method = 'GET'
 54 | 
 55 |     # path to endpoint
 56 |     path = ('/v3/accounts/', AccountID, '/positions/', InstrumentName)
 57 | 
 58 |     # description of endpoint
 59 |     description = 'Get the details of a single Instrument’s Position in an Account. The Position may by open or not.'
 60 | 
 61 |     # parameters required to send to endpoint
 62 |     parameters = {Authorization: (HEADER, 'Authorization'), AccountID: (PATH, 'accountID'),
 63 |                   InstrumentName: (PATH, 'instrument')}
 64 | 
 65 |     # valid responses
 66 |     responses = {200: {'position': Position, 'lastTransactionID': TransactionID}}
 67 | 
 68 |     # error msgs'
 69 |     error = (401, 404, 405)
 70 | 
 71 | 
 72 | class PUTPositionsInstrumentClose(EndPoint):
 73 |     # the HTTP verb to use for this endpoint
 74 |     method = 'PUT'
 75 | 
 76 |     # path to endpoint
 77 |     path = ('/v3/accounts/', AccountID, '/positions/', InstrumentName, '/close')
 78 | 
 79 |     # description of endpoint
 80 |     description = 'Closeout the open Position for a specific instrument in an Account.'
 81 | 
 82 |     # parameters required to send to endpoint
 83 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
 84 |                   AccountID: (PATH, 'accountID'), InstrumentName: (PATH, 'instrument')}
 85 | 
 86 |     # valid responses
 87 |     responses = {
 88 |         200: {'longOrderCreateTransaction': MarketOrderTransaction, 'longOrderFillTransaction': OrderFillTransaction,
 89 |               'longOrderCancelTransaction': OrderCancelTransaction,
 90 |               'shortOrderCreateTransaction': MarketOrderTransaction, 'shortOrderFillTransaction': OrderFillTransaction,
 91 |               'shortOrderCancelTransaction': OrderCancelTransaction, 'relatedTransactionIDs': ArrayTransactionID,
 92 |               'lastTransactionID': TransactionID},
 93 |         400: {'longOrderRejectTransaction': MarketOrderRejectTransaction,
 94 |               'shortOrderRejectTransaction': MarketOrderRejectTransaction,
 95 |               'relatedTransactionIDs': ArrayTransactionID, 'lastTransactionID': TransactionID, 'errorCode': str,
 96 |               'errorMessage': str},
 97 |         404: {'longOrderRejectTransaction': MarketOrderRejectTransaction,
 98 |               'shortOrderRejectTransaction': MarketOrderRejectTransaction,
 99 |               'relatedTransactionIDs': ArrayTransactionID, 'lastTransactionID': TransactionID, 'errorCode': str,
100 |               'errorMessage': str}}
101 | 
102 |     # error msgs'
103 |     error = (401, 405)
104 | 
105 |     # json schema representation
106 |     request_schema = {LongUnits: 'longUnits', LongClientExtensions: 'longClientExtensions', ShortUnits: 'shortUnits',
107 |                       ShortClientExtensions: 'shortClientExtensions'}
108 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/pricing.py:
--------------------------------------------------------------------------------
 1 | from .annotations import *
 2 | from .base import EndPoint, HEADER, PATH, QUERY
 3 | from ..definitions.primitives import *
 4 | from ..definitions.types import *
 5 | 
 6 | __all__ = ['GETPricing', 'GETPricingStream']
 7 | 
 8 | 
 9 | class GETPricing(EndPoint):
10 |     # the HTTP verb to use for this endpoint
11 |     method = 'GET'
12 | 
13 |     # path to endpoint
14 |     path = ('/v3/accounts/', AccountID, '/pricing')
15 | 
16 |     # description of endpoint
17 |     description = 'Get pricing information for a specified list of Instruments within an Account.'
18 | 
19 |     # parameters required to send to endpoint
20 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
21 |                   AccountID: (PATH, 'accountID'), Instruments: (QUERY, 'instruments'), DateTime: (QUERY, 'since')}
22 | 
23 |     # valid responses
24 |     responses = {200: {'prices': ArrayPrice, 'time': DateTime}}
25 | 
26 |     # error msgs'
27 |     error = (400, 401, 404, 405)
28 | 
29 | 
30 | class GETPricingStream(EndPoint):
31 |     # host to use for this endpoint
32 |     host = 'STREAM'
33 | 
34 |     # the HTTP verb to use for this endpoint
35 |     method = 'GET'
36 | 
37 |     # path to endpoint
38 |     path = ('/v3/accounts/', AccountID, '/pricing/stream')
39 | 
40 |     # description of endpoint
41 |     description = '''Get a stream of Account Prices starting from when the request is made.
42 |     This pricing stream does not include every single price created for the Account, 
43 |     but instead will provide at most 4 prices per second (every 250 milliseconds) 
44 |     for each instrument being requested. If more than one price is created for an instrument 
45 |     during the 250 millisecond window, only the price in effect at the end of the window is sent.
46 |     This means that during periods of rapid price movement, subscribers to this stream will 
47 |     not be sent every price. Pricing windows for different connections to the price stream 
48 |     are not all aligned in the same way (i.e.they are not all aligned to the top of the second).
49 |     This means that during periods of rapid price movement, different subscribers may observe 
50 |     different prices depending on their alignment.'''
51 | 
52 |     # parameters required to send to endpoint
53 |     parameters = {Authorization: (HEADER, 'Authorization'), AcceptDatetimeFormat: (HEADER, 'Accept-Datetime-Format'),
54 |                   AccountID: (PATH, 'accountID'), Instruments: (QUERY, 'instruments'), Snapshot: (QUERY, 'snapshot')}
55 | 
56 |     # valid responses
57 |     responses = {200: {'PRICE': Price, 'HEARTBEAT': PricingHeartbeat}}
58 | 
59 |     # error msgs'
60 |     error = (400, 401, 404, 405)
61 | 


--------------------------------------------------------------------------------
/async_v20/endpoints/user.py:
--------------------------------------------------------------------------------
 1 | from .annotations import UserSpecifier, Authorization
 2 | from .base import EndPoint, HEADER, QUERY
 3 | from ..definitions.types import *
 4 | 
 5 | __all__ = ['GETUserSpecifier', 'GETExternalInfo']
 6 | 
 7 | 
 8 | class GETUserSpecifier(EndPoint):
 9 |     # the HTTP verb to use for this endpoint
10 |     method = 'GET'
11 | 
12 |     # path to endpoint
13 |     path = ('/v3/users/', UserSpecifier)
14 | 
15 |     # description of endpoint
16 |     description = 'Fetch the user information for the specified user.'
17 | 
18 |     # parameters required to send to endpoint
19 |     parameters = {Authorization: (HEADER, 'Authorization'), UserSpecifier: (QUERY, 'userSpecifier')}
20 | 
21 |     # valid responses
22 |     responses = {200: {'userInfo': UserInfo}}
23 | 
24 |     # error msgs'
25 |     error = [401, 403, 405]
26 | 
27 | 
28 | class GETExternalInfo(EndPoint):
29 |     # the HTTP verb to use for this endpoint
30 |     method = 'GET'
31 | 
32 |     # path to endpoint
33 |     path = ('/v3/users/', UserSpecifier, '/externalInfo')
34 | 
35 |     # description of endpoint
36 |     description = 'Fetch the externally-available user information for the specified user.'
37 | 
38 |     # parameters required to send to endpoint
39 |     parameters = {Authorization: (HEADER, 'Authorization'), UserSpecifier: (QUERY, 'userSpecifier')}
40 | 
41 |     # valid responses
42 |     responses = {200: {'userInfo': UserInfoExternal}}
43 | 
44 |     # error msgs'
45 |     error = (401, 403, 405)
46 | 


--------------------------------------------------------------------------------
/async_v20/exceptions.py:
--------------------------------------------------------------------------------
 1 | class AsyncV20Exception(Exception):
 2 |     """A base exception for all exceptions in the async_v20 package"""
 3 |     pass
 4 | 
 5 | class AsyncV20Warning(Warning):
 6 |     """A base warning for all warnings in the async_v20 package"""
 7 |     pass
 8 | 
 9 | class InitializationFailure(AsyncV20Exception):
10 |     """OandaClient Failed to initialize"""
11 |     pass
12 | 
13 | class ResponseTimeout(AsyncV20Exception):
14 |     """The server took to long to respond"""
15 |     pass
16 | 
17 | class CloseAllTradesFailure(AsyncV20Exception):
18 |     """Failed to close all trades"""
19 |     pass
20 | 
21 | class InvalidValue(AsyncV20Exception):
22 |     """A supplied value does not meet the specification
23 |     of valid values"""
24 |     pass
25 | 
26 | class InvalidFormatArguments(AsyncV20Exception):
27 |     """Arguments to format a DecimalNumber or PriceValue
28 |     are invalid"""
29 |     pass
30 | 
31 | class IncompatibleValue(AsyncV20Exception):
32 |     """A supplied argument is different than the predefined value"""
33 |     pass
34 | 
35 | class UnknownKeywordArgument(AsyncV20Warning):
36 |     """A passed keyword argument is not in the objects __init__ signature"""
37 |     pass
38 | 
39 | class InstantiationFailure(AsyncV20Exception):
40 |     """async_v20 was unable to create an object from the passed arguments"""
41 |     pass
42 | 
43 | class UnexpectedStatus(AsyncV20Exception):
44 |     """The server returned an unexpected HTTP status"""
45 |     pass
46 | 
47 | class FailedToCreatePath(AsyncV20Exception):
48 |     """Unable to construct the path for the requested endpoint"""
49 |     pass
50 | 
51 | class InvalidOrderRequest(AsyncV20Exception):
52 |     """The order request is not with in the instruments specification
53 |     the order is for"""
54 |     pass


--------------------------------------------------------------------------------
/async_v20/interface/__init__.py:
--------------------------------------------------------------------------------
 1 | from .account import *
 2 | from .instrument import *
 3 | from .order import *
 4 | from .position import *
 5 | from .pricing import *
 6 | from .trade import *
 7 | from .transaction import *
 8 | from .user import *
 9 | from .health import *
10 | __all__ = (
11 |     account.__all__ +
12 |     instrument.__all__ +
13 |     order.__all__ +
14 |     position.__all__ +
15 |     pricing.__all__ +
16 |     trade.__all__ +
17 |     transaction.__all__ +
18 |     user.__all__ +
19 |     health.__all__
20 | )
21 | 


--------------------------------------------------------------------------------
/async_v20/interface/account.py:
--------------------------------------------------------------------------------
  1 | from .decorators import endpoint
  2 | from ..definitions.types import DecimalNumber
  3 | from ..endpoints.account import *
  4 | from ..endpoints.annotations import Alias
  5 | from ..endpoints.annotations import Instruments
  6 | from ..endpoints.annotations import SinceTransactionID
  7 | from ..definitions.helpers import sentinel
  8 | 
  9 | __all__ = ['AccountInterface']
 10 | 
 11 | 
 12 | class AccountInterface(object):
 13 |     @endpoint(GETAccounts, initialize_required=False)
 14 |     def list_accounts(self):
 15 |         """Get a list of all Accounts authorized for the provided token.
 16 | 
 17 |         Returns:
 18 | 
 19 |             status [200]
 20 |                 :class:`~async_v20.interface.response.Response`
 21 |                 (accounts=( :class:`~async_v20.AccountProperties`, ...),)
 22 | 
 23 |         """
 24 |         pass
 25 | 
 26 |     @endpoint(GETAccountID, initialize_required=False)
 27 |     def get_account_details(self):
 28 |         """
 29 |         Get the full details for a single Account that a client has access to.
 30 |         Full pending Order, open Trade and open Position representations are
 31 |         provided.
 32 | 
 33 |         Returns:
 34 | 
 35 |             status [200]
 36 |                 :class:`~async_v20.interface.response.Response`
 37 |                 (account= :class:`~async_v20.Account`,
 38 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 39 |         """
 40 |         pass
 41 | 
 42 |     @endpoint(GETAccountIDSummary)
 43 |     def account_summary(self):
 44 |         """
 45 |         Get a summary for a single Account that a client has access to.
 46 | 
 47 |         Returns:
 48 | 
 49 |             status [200]
 50 |                 :class:`~async_v20.interface.response.Response`
 51 |                 (account= :class:`~async_v20.AccountSummary`,
 52 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 53 |         """
 54 |         pass
 55 | 
 56 |     @endpoint(GETAccountIDInstruments)
 57 |     def account_instruments(self, instruments: Instruments = sentinel):
 58 |         """
 59 |         Get the list of tradeable instruments for the given Account. The list
 60 |         of tradeable instruments is dependent on the regulatory division that
 61 |         the Account is located in, thus should be the same for all Accounts
 62 |         owned by a single user.
 63 | 
 64 |         Args:
 65 | 
 66 |             instruments: :class:`~async_v20.endpoints.annotations.Instruments`
 67 |             list of instruments to query specifically.
 68 | 
 69 |         Returns:
 70 | 
 71 |             status [200]
 72 |                 :class:`~async_v20.interface.response.Response`
 73 |                 (instruments=( :class:`~async_v20.Instrument`, ...),
 74 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 75 |         """
 76 |         pass
 77 | 
 78 |     @endpoint(PATCHAccountIDConfiguration)
 79 |     def configure_account(self, alias: Alias = sentinel, margin_rate: DecimalNumber = sentinel):
 80 |         """
 81 |         Set the client-configurable portions of an Account.
 82 | 
 83 |         Args:
 84 | 
 85 |             alias: :class:`~async_v20.endpoints.annotations.Alias`
 86 |                 Client-defined alias (name) for the Account
 87 |             margin_rate: :class:`~async_v20.DecimalNumber`
 88 |                 The string representation of a decimal number.
 89 | 
 90 |         Returns:
 91 | 
 92 |             status [200]
 93 |                 :class:`~async_v20.interface.response.Response`
 94 |                 (clientConfigureTransaction= :class:`~async_v20.ClientConfigureTransaction`,
 95 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 96 | 
 97 |             status [400]
 98 |                 :class:`~async_v20.interface.response.Response`
 99 |                 (clientConfigureRejectTransaction= :class:`~async_v20.ClientConfigureRejectTransaction`,
100 |                 lastTransactionID= :class:`~async_v20.TransactionID`,
101 |                 errorCode= :class:`~builtins.str`,
102 |                 errorMessage= :class:`~builtins.str`)
103 | 
104 |             status [403]
105 |                 :class:`~async_v20.interface.response.Response`
106 |                 (clientConfigureRejectTransaction= :class:`~async_v20.ClientConfigureRejectTransaction`,
107 |                 lastTransactionID= :class:`~async_v20.TransactionID`,
108 |                 errorCode= :class:`~builtins.str`,
109 |                 errorMessage= :class:`~builtins.str`)
110 | 
111 |         """
112 |         pass
113 | 
114 |     @endpoint(GETAccountIDChanges, rest=True)
115 |     def account_changes(self, since_transaction_id: SinceTransactionID = sentinel):
116 |         """
117 |         Endpoint used to poll an Account for its current state and changes
118 |         since a specified TransactionID.
119 | 
120 |         Note:
121 |             OandaClient will supply since_transaction_id if None is provided
122 | 
123 |         Args:
124 |             since_transaction_id: :class:`~async_v20.endpoints.annotations.SinceTransactionID`
125 |                 ID of the Transaction to get Account changes since.
126 | 
127 |         Returns:
128 | 
129 |             status [200]
130 |                 :class:`~async_v20.interface.response.Response`
131 |                 (changes= :class:`~async_v20.AccountChanges`,
132 |                 state= :class:`~async_v20.AccountChangesState`,
133 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
134 |         """
135 |         pass
136 | 


--------------------------------------------------------------------------------
/async_v20/interface/decorators.py:
--------------------------------------------------------------------------------
 1 | """Module that defines the behaviour of the exposed client method calls by using decorators
 2 | """
 3 | import logging
 4 | from functools import wraps
 5 | from inspect import signature
 6 | 
 7 | from .helpers import create_request_kwargs, construct_arguments
 8 | from .parser import parse_response
 9 | from ..definitions.helpers import create_doc_signature
10 | from ..endpoints.annotations import SinceTransactionID
11 | from ..exceptions import ResponseTimeout
12 | from asyncio import TimeoutError as AsyncTimeOutError
13 | logger = logging.getLogger(__name__)
14 | 
15 | 
16 | def endpoint(endpoint, rest=False, initialize_required=True):
17 |     """Define a method call to be exposed to the user"""
18 | 
19 |     def wrapper(method):
20 |         """Take the wrapped method and return a coroutine"""
21 | 
22 |         method.endpoint = endpoint
23 | 
24 |         method.initialize_required = initialize_required
25 | 
26 |         sig = signature(method)
27 | 
28 |         method.__doc__ = create_doc_signature(method, sig)
29 | 
30 |         @wraps(method)
31 |         async def wrap(self, *args, **kwargs):
32 |             if initialize_required:
33 |                 await self.initialize(method.__name__)
34 |             elif not self.session:
35 |                 await self.initialize_session()
36 | 
37 |             logger.info('%s(args=%s, kwargs=%s)', method.__name__, args, kwargs)
38 |             arguments = construct_arguments(self, sig, *args, **kwargs)
39 | 
40 |             enable_rest = False
41 |             if rest and arguments[SinceTransactionID] == self.default_parameters[SinceTransactionID]:
42 |                 enable_rest = True
43 | 
44 |             request_kwargs = create_request_kwargs(self, endpoint, arguments)
45 | 
46 |             await self._request_limiter()
47 | 
48 |             if self.debug:
49 |                 logger.debug('client.session.request(kwargs=%s)', request_kwargs)
50 |             response = self.session.request(**request_kwargs)
51 | 
52 |             return await parse_response(self, response, endpoint, enable_rest, method.__name__)
53 | 
54 | 
55 |         wrap.__signature__ = sig
56 | 
57 |         return wrap
58 | 
59 |     return wrapper
60 | 
61 | 
62 | def shortcut(func):
63 |     sig = signature(func)
64 | 
65 |     @wraps(func)
66 |     def wrap(self, *args, **kwargs):
67 |         return func(self, *args, **kwargs)
68 | 
69 |     wrap.shortcut = True
70 |     wrap.__signature__ = sig
71 |     wrap.__doc__ = create_doc_signature(wrap, sig)
72 | 
73 |     return wrap
74 | 


--------------------------------------------------------------------------------
/async_v20/interface/health.py:
--------------------------------------------------------------------------------
  1 | from .decorators import endpoint
  2 | from ..endpoints.health import *
  3 | 
  4 | __all__ = ['HealthInterface']
  5 | 
  6 | 
  7 | class HealthInterface(object):
  8 |     @endpoint(GETServices, initialize_required=False)
  9 |     def list_services(self):
 10 |         """List all the services
 11 | 
 12 |         Returns:
 13 | 
 14 |             status [200]
 15 |                 :class:`~async_v20.interface.response.Response`
 16 |                 (services=( :class:`~async_v20.definitions.health_types.Service`, ...))
 17 | 
 18 |         """
 19 |         pass
 20 | 
 21 |     @endpoint(GETService, initialize_required=False)
 22 |     def get_service(self, service_id: ServiceID):
 23 |         """Get a single service
 24 | 
 25 |         Args:
 26 | 
 27 |             service_id: :class:`~async_v20.endpoints.annotations.ServiceID`
 28 |                 Name of the service to get
 29 | 
 30 |         Returns:
 31 | 
 32 |             status [200]
 33 |                 :class:`~async_v20.interface.response.Response`
 34 |                 (Service= :class:`~async_v20.definitions.health_types.Service`)
 35 | 
 36 |         """
 37 |         pass
 38 | 
 39 |     @endpoint(GETServiceLists, initialize_required=False)
 40 |     def list_service_lists(self):
 41 |         """List all service lists
 42 | 
 43 |         Returns:
 44 | 
 45 |             status [200]
 46 |                 :class:`~async_v20.interface.response.Response`
 47 |                 (lists=( :class:`~async_v20.definitions.health_types.ServiceList`, ...))
 48 |         """
 49 |         pass
 50 | 
 51 |     @endpoint(GETServiceList, initialize_required=False)
 52 |     def get_service_list(self, service_list_id: ServiceListID):
 53 |         """Get a single service list
 54 | 
 55 |         Args:
 56 | 
 57 |             service_list_id: :class:`~async_v20.endpoints.annotations.ServiceListID`
 58 |                 The service list to get.
 59 | 
 60 |         Returns:
 61 | 
 62 |             status [200]
 63 |                 :class:`~async_v20.interface.response.Response`
 64 |                 (lists= :class:`~async_v20.definitions.health_types.ServiceList`)
 65 |         """
 66 |         pass
 67 | 
 68 |     @endpoint(GETEvents, initialize_required=False)
 69 |     def list_events(self, service_id: ServiceID):
 70 |         """List all events for a service
 71 | 
 72 |         Args:
 73 | 
 74 |             service_id: :class:`~async_v20.endpoints.annotations.ServiceID`
 75 |                 The service to get events for.
 76 | 
 77 |         Returns:
 78 | 
 79 |             status [200]
 80 |                 :class:`~async_v20.interface.response.Response`
 81 |                 (lists=( :class:`~async_v20.definitions.health_types.Event`,...))
 82 |         """
 83 |         pass
 84 | 
 85 |     @endpoint(GETCurrentEvent, initialize_required=False)
 86 |     def get_current_event(self, service_id: ServiceID):
 87 |         """Get the current event for a service
 88 | 
 89 |         Args:
 90 | 
 91 |             service_id: :class:`~async_v20.endpoints.annotations.ServiceID`
 92 |                 The service to get the current event for
 93 | 
 94 |         Returns:
 95 | 
 96 |             status [200]
 97 |                 :class:`~async_v20.interface.response.Response`
 98 |                 (Event= :class:`~async_v20.definitions.health_types.Event`)
 99 |         """
100 |         pass
101 | 
102 |     @endpoint(GETEvent, initialize_required=False)
103 |     def get_event(self, service_id: ServiceID, event_sid: EventSid):
104 |         """Get an individual event
105 | 
106 |         Args:
107 | 
108 |             service_id: :class:`~async_v20.endpoints.annotations.ServiceID`
109 |                 The service to event for
110 |             event_sid: :class:`~async_v20.endpoints.annotations.EventSid`
111 |                 The event to get from the specified service
112 | 
113 |         Returns:
114 | 
115 |             status [200]
116 |                 :class:`~async_v20.interface.response.Response`
117 |                 (Event= :class:`~async_v20.definitions.health_types.Event`)
118 |         """
119 |         pass
120 | 
121 |     @endpoint(GETStatuses, initialize_required=False)
122 |     def list_statuses(self):
123 |         """List all statuses
124 | 
125 |         Returns:
126 | 
127 |             status [200]
128 |                 :class:`~async_v20.interface.response.Response`
129 |                 (statuses=( :class:`~async_v20.definitions.health_types.Event`, ...))
130 |         """
131 |         pass
132 | 
133 |     @endpoint(GETStatus, initialize_required=False)
134 |     def get_status(self, status_id: StatusID):
135 |         """Get an individual status
136 | 
137 |         Args:
138 | 
139 |             status_id: :class:`~async_v20.endpoints.annotations.StatusID`
140 |                 The status to get
141 | 
142 |         Returns:
143 | 
144 |             status [200]
145 |                 :class:`~async_v20.interface.response.Response`
146 |                 (Status= :class:`~async_v20.definitions.health_types.Status`)
147 |         """
148 |         pass
149 | 
150 |     @endpoint(GETImages, initialize_required=False)
151 |     def list_images(self):
152 |         """List all status images
153 | 
154 |         Returns:
155 | 
156 |             status [200]
157 |                 :class:`~async_v20.interface.response.Response`
158 |                 (images=( :class:`~async_v20.definitions.health_types.Image`, ...))
159 |         """
160 |         pass
161 | 


--------------------------------------------------------------------------------
/async_v20/interface/parser.py:
--------------------------------------------------------------------------------
  1 | import ujson as json
  2 | from asyncio import TimeoutError as AsyncTimeOutError
  3 | from async_timeout import timeout
  4 | import logging
  5 | from .response import Response
  6 | from .rest import update_account
  7 | from ..definitions.base import create_attribute
  8 | from ..endpoints.account import GETAccountID
  9 | from ..endpoints.annotations import LastTransactionID
 10 | from ..endpoints.annotations import SinceTransactionID
 11 | from ..endpoints.other_responses import other_responses
 12 | from ..endpoints.pricing import GETPricingStream
 13 | from ..endpoints.transaction import GETTransactionsStream
 14 | from ..exceptions import ResponseTimeout, UnexpectedStatus
 15 | 
 16 | from time import time
 17 | 
 18 | TRANSACTION = 'transaction'
 19 | HEARTBEAT = 'heartbeat'
 20 | PRICE = 'price'
 21 | 
 22 | logger = logging.getLogger(__name__)
 23 | 
 24 | def _lookup_schema(endpoint, status):
 25 |     try:
 26 |         schema = endpoint.responses[status]  # look up the template to process the data
 27 |     except KeyError:
 28 |         try:
 29 |             schema = other_responses[status]  # See if a response status is an error code
 30 |         except KeyError:
 31 |             msg = str(status)
 32 |             logger.error(msg)
 33 |             raise UnexpectedStatus(msg)
 34 |         else:
 35 |             # Returns False if the status wasn't in the endpoints expected response
 36 |             return schema, status, False
 37 |     else:
 38 |         # Returns true if the status was a valid response
 39 |         return schema, status, True
 40 | 
 41 | 
 42 | async def _create_response(json_body, endpoint, schema, status, boolean, datetime_format):
 43 |     # Here we iterate through all the json objects returned in the response
 44 |     # and construct the corresponding async_v20 type as determined by the endpoints
 45 |     # Schema
 46 |     if isinstance(schema, dict):
 47 |         data = []
 48 |         for json_object, json_field in json_body.items():
 49 |             data.append((json_object, create_attribute(schema.get(json_object), json_field)))
 50 |     else:
 51 |         obj = schema(**json_body)
 52 |         data = [(obj.__class__.__name__, obj)]
 53 |     return Response(data, status, boolean, datetime_format)
 54 | 
 55 | 
 56 | async def _rest_response(self, response, endpoint, enable_rest, method_name):
 57 |     try:
 58 |         async with timeout(self.rest_timeout):
 59 |             async with response as resp:
 60 |                 schema, status, boolean = _lookup_schema(endpoint, resp.status)
 61 |                 # Update client headers.
 62 |                 self.default_parameters.update(resp.raw_headers)
 63 |                 json_body = await resp.json()
 64 | 
 65 |     except AsyncTimeOutError:
 66 |         msg = f'{method_name} took longer than {self.rest_timeout} seconds'
 67 |         logger.error(msg)
 68 |         raise ResponseTimeout(msg)
 69 |     else:
 70 |         response = await _create_response(json_body, endpoint, schema, status, boolean, self.datetime_format)
 71 | 
 72 |     if response:
 73 |         last_transaction_id = getattr(response, 'lastTransactionID', None)
 74 |         if last_transaction_id:
 75 |             self.default_parameters.update({LastTransactionID: last_transaction_id})
 76 | 
 77 |             # This code is to implement the RESTful nature of the v20 API
 78 |             # - Keep track of the last transaction id used to update
 79 |             # - Add / Remove / Replace changes to account
 80 |             if enable_rest:
 81 |                 self.default_parameters.update({SinceTransactionID: last_transaction_id})
 82 |                 update_account(self, response.changes, response.state)
 83 | 
 84 |         if endpoint == GETAccountID:
 85 |             # Means account_details was requested. So we catch the account state on the way through.
 86 |             # This occurs during initialization of OandaClient.
 87 |             self.default_parameters.update({SinceTransactionID: last_transaction_id})
 88 |             self._account = response.account
 89 | 
 90 |     return response
 91 | 
 92 | 
 93 | def _construct_json_body_and_schema(line, schema, endpoint):
 94 |     """This helper function standardises the streaming responses"""
 95 |     try:
 96 |         typ = line['type']
 97 |         obj = schema[typ]
 98 |         key = None
 99 |         if HEARTBEAT in typ.lower():
100 |             key = HEARTBEAT
101 |         elif endpoint == GETPricingStream:
102 |             key = PRICE
103 |         elif endpoint == GETTransactionsStream:
104 |             key = TRANSACTION
105 |     except KeyError:
106 |         json_body, json_schema = line, schema
107 |     else:
108 |         json_body, json_schema = {key: line}, {key: obj}
109 |     return json_body, json_schema
110 | 
111 | 
112 | async def _stream_parser(self, response, endpoint, method_name):
113 |     async with response as resp:
114 |         schema, status, boolean = _lookup_schema(endpoint, resp.status)
115 |         while not resp.content.at_eof():
116 |             try:
117 |                 async with timeout(self.stream_timeout):
118 |                     line = json.loads(await resp.content.readline())
119 |             except AsyncTimeOutError:
120 |                 msg = f'{method_name} took longer than {self.stream_timeout} seconds'
121 |                 logger.error(msg)
122 |                 raise ResponseTimeout(msg)
123 | 
124 |             json_body, json_schema = _construct_json_body_and_schema(line, schema, endpoint)
125 | 
126 |             yield await _create_response(json_body, endpoint, json_schema, status, boolean, self.datetime_format)
127 | 
128 | 
129 | async def parse_response(self, response, endpoint, enable_rest, method_name):
130 |     if endpoint.host in 'REST HEALTH':
131 |         result = await _rest_response(self, response, endpoint, enable_rest, method_name)
132 |     else:
133 |         result = _stream_parser(self, response, endpoint, method_name)
134 |     return result
135 | 


--------------------------------------------------------------------------------
/async_v20/interface/pricing.py:
--------------------------------------------------------------------------------
 1 | from .decorators import endpoint
 2 | from ..definitions.types import DateTime
 3 | from ..endpoints.annotations import *
 4 | from ..endpoints.pricing import *
 5 | from ..definitions.helpers import sentinel
 6 | 
 7 | __all__ = ['PricingInterface']
 8 | 
 9 | 
10 | class PricingInterface(object):
11 |     @endpoint(GETPricing)
12 |     def get_pricing(self,
13 |                     instruments: Instruments = sentinel,
14 |                     since: DateTime = sentinel):
15 |         """
16 |         Get pricing information for a specified list of Instruments within an
17 |         Account.
18 | 
19 |         Args:
20 | 
21 |             instruments: :class:`~async_v20.endpoints.annotations.Instruments`
22 |             list of Instruments to get pricing for.
23 |             since: :class:`~async_v20.DateTime`
24 |                 Date/Time filter to apply to the returned prices. Only prices
25 |                 with a time later than this filter will be provided.
26 | 
27 |         Returns:
28 | 
29 |             status [200]
30 |                 :class:`~async_v20.interface.response.Response`
31 |                 (prices=( :class:`~async_v20.Price`, ...),
32 |                 time= :class:`~async_v20.DateTime`)
33 |         """
34 |         pass
35 | 
36 |     @endpoint(GETPricingStream)
37 |     def stream_pricing(self,
38 |                        instruments: Instruments = sentinel,
39 |                        snapshot: Snapshot = sentinel):
40 |         """
41 |         Get a stream of Account Prices starting from when the request is made.
42 |         This pricing stream does not include every single price created for the
43 |         Account, but instead will provide at most 4 prices per second (every
44 |         250 milliseconds) for each instrument being requested. If more than one
45 |         price is created for an instrument during the 250 millisecond window,
46 |         only the price in effect at the end of the window is sent. This means
47 |         that during periods of rapid price movement, subscribers to this stream
48 |         will not be sent every price. Pricing windows for different connections
49 |         to the price stream are not all aligned in the same way (i.e. they are
50 |         not all aligned to the top of the second). This means that during
51 |         periods of rapid price movement, different subscribers may observe
52 |         different prices depending on their alignment.
53 | 
54 |         Args:
55 | 
56 |             instruments: :class:`~async_v20.endpoints.annotations.Instruments`
57 |             list of Instruments to stream Prices for.
58 |             snapshot: :class:`~async_v20.endpoints.annotations.Snapshot`
59 |                 Flag that enables/disables the sending of a pricing snapshot
60 |                 when initially connecting to the stream.
61 | 
62 |         Returns:
63 | 
64 |             status [200]
65 |                 :class:`~async_v20.interface.response.Response`
66 |                 (price= :class:`~async_v20.Price`)
67 | 
68 |                 **OR**
69 | 
70 |                 :class:`~async_v20.interface.response.Response`
71 |                 (heartbeat= :class:`~async_v20.PricingHeartbeat`)
72 | 
73 | 
74 |         """
75 |         pass
76 | 


--------------------------------------------------------------------------------
/async_v20/interface/response.py:
--------------------------------------------------------------------------------
 1 | import ujson as json
 2 | import logging
 3 | from ..definitions.base import Specifier, Model, Array
 4 | import pandas as pd
 5 | 
 6 | logger = logging.getLogger(__name__)
 7 | 
 8 | class Response(dict):
 9 |     """A response from OANDA.
10 | 
11 |     Allows dotted attribute access
12 |     """
13 |     def __init__(self, data, status, bool, datetime_format):
14 |         if data:
15 |             super().__init__(data)
16 |         self.status = status
17 |         self.bool = bool
18 |         self.datetime_format = datetime_format
19 | 
20 |     def __bool__(self):
21 |         """Returns True if response contains data as per the OANDA spec.
22 | 
23 |         Returns false if a status code not defined in the endpoint spec was returned
24 |         """
25 |         return self.bool
26 | 
27 |     def __repr__(self):
28 |         keys = ', '.join(self.keys())
29 |         return f'<Status [{self.status}]: {keys}>'
30 | 
31 |     def __getattr__(self, name):
32 |         try:
33 |             return self[name]
34 |         except KeyError:
35 |             msg = f'No such attribute `{name}`'
36 |             raise AttributeError(msg)
37 | 
38 |     def dict(self, json=False, datetime_format=None):
39 |         """Convert the response to a nested dictionary
40 | 
41 |         Args:
42 | 
43 |             json: Convert object attributes to the :term:`JSON` representation
44 | 
45 |         """
46 |         if json and datetime_format is None:
47 |             datetime_format = self.datetime_format
48 | 
49 | 
50 |         def value_to_dict(value):
51 |             if isinstance(value, Model):
52 |                 result = value.dict(json, datetime_format)
53 |             elif isinstance(value, Array):
54 |                 try:
55 |                     result = [obj.dict(json, datetime_format) for obj in value]
56 |                 except AttributeError:
57 |                     result = [obj for obj in value]
58 |             elif isinstance(value, Specifier) and json:
59 |                     # Specifiers need to be strings for JSON
60 |                 result = str(value)
61 |             elif isinstance(value, pd.Timestamp) and json:
62 |                 result = value.json(datetime_format)
63 |             else:
64 |                 result = value
65 |             return result
66 | 
67 |         return {key: value_to_dict(value) for key, value in self.items()}
68 | 
69 |     def json(self, datetime_format=None):
70 |         """Return the json equivalent of the response"""
71 |         return json.dumps(self.dict(json=True, datetime_format=datetime_format))
72 | 


--------------------------------------------------------------------------------
/async_v20/interface/rest.py:
--------------------------------------------------------------------------------
 1 | """module dedicated to implementing the RESTful client"""
 2 | 
 3 | from itertools import chain
 4 | 
 5 | from async_v20.definitions.types import ArrayTransaction
 6 | 
 7 | 
 8 | def update_account(self, changes, changes_state):
 9 |     """Update an existing account with changes
10 | 
11 |     Args:
12 |         self: -- OandaClient instance
13 |         changes: -- Changes from account_changes API call
14 |         changes_state: ChangesState from account_changes API call
15 | 
16 |     Returns: None
17 |     """
18 | 
19 |     # Add / Replace / Remove items from the AccountChanges object
20 |     orders = (order if not changes.orders_filled.get_id(order.id)
21 |               else changes.orders_filled.get_id(order.id)
22 |               for order in chain(self._account.orders, changes.orders_created)
23 |               if not changes.orders_cancelled.get_id(order.id)
24 |               and not changes.orders_filled.get_id(order.id))
25 | 
26 |     trades = (trade if not changes.trades_reduced.get_id(trade.id)
27 |               else changes.trades_reduced.get_id(trade.id)
28 |               for trade in chain(self._account.trades, changes.trades_opened)
29 |               if not changes.trades_closed.get_id(trade.id))
30 | 
31 |     # We need to replace any positions in the stored account with the changed positions
32 |     # and then we need to update the dynamic state
33 |     positions = {position.instrument: position
34 |                  for position in self._account.positions}
35 | 
36 |     positions.update({
37 |         position.instrument: position for position in changes.positions
38 |     })
39 | 
40 |     positions = ((position, changes_state.positions.get_instrument(instrument))
41 |                  for instrument, position in positions.items())
42 | 
43 |     # Update the Dynamic state
44 |     orders = tuple(order if not changes_state.orders.get_id(order.id)
45 |                    else order.replace(**changes_state.orders.get_id(order.id).dict())
46 |                    for order in orders)
47 | 
48 |     trades = tuple(trade if not changes_state.trades.get_id(trade.id)
49 |                    else trade.replace(**changes_state.trades.get_id(trade.id).dict())
50 |                    for trade in trades)
51 | 
52 |     positions = tuple(
53 |         position.replace(
54 |             unrealized_pl=0,
55 |             long=position.long.replace(unrealized_pl=0),
56 |             short=position.short.replace(unrealized_pl=0))
57 |         if not state
58 |         else position.replace(
59 |             unrealized_pl=state.net_unrealized_pl,
60 |             long=position.long.replace(unrealized_pl=state.long_unrealized_pl),
61 |             short=position.short.replace(unrealized_pl=state.short_unrealized_pl))
62 |         for position, state in positions)
63 | 
64 |     self._account = self._account.replace(**dict(changes_state.dict(json=False),
65 |                                                  orders=orders, trades=trades, positions=positions))
66 | 
67 |     self.transactions = ArrayTransaction(
68 |         *sorted((changes.transactions + self.transactions)[-self.max_transaction_history:],
69 |                 key=lambda x: x.id, reverse=True))
70 | 


--------------------------------------------------------------------------------
/async_v20/interface/transaction.py:
--------------------------------------------------------------------------------
  1 | from .decorators import endpoint
  2 | from ..definitions.types import TransactionID
  3 | from ..endpoints.annotations import FromTime
  4 | from ..endpoints.annotations import FromTransactionID
  5 | from ..endpoints.annotations import PageSize
  6 | from ..endpoints.annotations import ToTime
  7 | from ..endpoints.annotations import ToTransactionID
  8 | from ..endpoints.annotations import Type
  9 | from ..endpoints.transaction import *
 10 | from ..definitions.helpers import sentinel
 11 | 
 12 | __all__ = ['TransactionInterface']
 13 | 
 14 | 
 15 | class TransactionInterface(object):
 16 |     @endpoint(GETTransactions)
 17 |     def list_transactions(self,
 18 |                           from_time: FromTime = sentinel,  # TODO should default to account creation time
 19 |                           to_time: ToTime = sentinel,  # TODO should default to request time
 20 |                           page_size: PageSize = 100,
 21 |                           type_: Type = sentinel):
 22 |         """
 23 |         Get a list of Transactions pages that satisfy a time-based Transaction
 24 |         query.
 25 | 
 26 |         Args:
 27 | 
 28 |             from_time: :class:`~async_v20.endpoints.annotations.FromTime`
 29 |                 The starting time (inclusive) of the time range for the
 30 |                 Transactions being queried.
 31 |             to_time: :class:`~async_v20.endpoints.annotations.ToTime`
 32 |                 The ending time (inclusive) of the time range for the
 33 |                 Transactions being queried.
 34 |             page_size: :class:`~async_v20.endpoints.annotations.PageSize`
 35 |                 The number of Transactions to include in each page of the
 36 |                 results.
 37 |             type_: :class:`~async_v20.endpoints.annotations.Type`
 38 |                 A filter for restricting the types of Transactions to retrieve.
 39 | 
 40 |         Returns:
 41 | 
 42 |             status [200]
 43 |                 :class:`~async_v20.interface.response.Response`
 44 |                 (from= :class:`~async_v20.DateTime`,
 45 |                 to= :class:`~async_v20.DateTime`,
 46 |                 pageSize= :class:`~builtins.int`,
 47 |                 type=( :class:`~async_v20.TransactionFilter`, ...),
 48 |                 count= :class:`~builtins.int`,
 49 |                 pages=( :class:`str`, ...),
 50 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 51 |         """
 52 |         pass
 53 | 
 54 |     @endpoint(GETTransactionID)
 55 |     def get_transaction(self, transaction_id: TransactionID):
 56 |         """
 57 |         Get the details of a single Account Transaction.
 58 | 
 59 |         Args:
 60 | 
 61 |             transaction_id: :class:`~async_v20.TransactionID`
 62 |                 A Transaction ID
 63 | 
 64 |         Returns:
 65 | 
 66 |             status [200]
 67 |                 :class:`~async_v20.interface.response.Response`
 68 |                 (transaction= :class:`~async_v20.Transaction`,
 69 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 70 |         """
 71 |         pass
 72 | 
 73 |     @endpoint(GETIDrange)
 74 |     def transaction_range(self,
 75 |                           from_transaction: FromTransactionID,
 76 |                           to_transaction: ToTransactionID,  # TODO make this default to now
 77 |                           type_: Type = sentinel):
 78 |         """
 79 |         Get a range of Transactions for an Account based on the Transaction
 80 |         IDs.
 81 | 
 82 |         Args:
 83 | 
 84 |             from_transaction: :class:`~async_v20.endpoints.annotations.FromTransactionID`
 85 |                 The starting Transaction ID (inclusive) to fetch.
 86 |             to_transaction: :class:`~async_v20.endpoints.annotations.ToTransactionID`
 87 |                 The ending Transaction ID (inclusive) to fetch.
 88 |             type_: :class:`~async_v20.endpoints.annotations.Type`
 89 |                 The filter that restricts the types of Transactions to
 90 |                 retrieve.
 91 | 
 92 |         Returns:
 93 | 
 94 |             status [200]
 95 |                 :class:`~async_v20.interface.response.Response`
 96 |                 (transactions=( :class:`~async_v20.Transaction`, ...),
 97 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
 98 |         """
 99 |         pass
100 | 
101 |     @endpoint(GETSinceID)
102 |     def since_transaction(self, transaction_id: TransactionID = sentinel):
103 |         """
104 |         Get a range of Transactions for an Account starting at (but not
105 |         including) a provided Transaction ID.
106 | 
107 |         Args:
108 | 
109 |             transaction_id: :class:`~async_v20.TransactionID`
110 |                 The ID of the last Transaction fetched. This query will return
111 |                 all Transactions newer than the TransactionID.
112 | 
113 |         Returns:
114 | 
115 |             status [200]
116 |                 :class:`~async_v20.interface.response.Response`
117 |                 (transactions=( :class:`~async_v20.Transaction`, ...),
118 |                 lastTransactionID= :class:`~async_v20.TransactionID`)
119 |         """
120 |         pass
121 | 
122 |     @endpoint(GETTransactionsStream)
123 |     def stream_transactions(self):
124 |         """
125 |         Get a stream of Transactions for an Account starting from when the
126 |         request is made.
127 | 
128 |         Returns:
129 | 
130 |             status [200]
131 |                 :class:`~async_v20.interface.response.Response`
132 |                 (transaction= :class:`~async_v20.Transaction`)
133 | 
134 | 
135 |                 **OR**
136 | 
137 | 
138 |                 :class:`~async_v20.interface.response.Response`
139 |                 (Heartbeat= :class:`~async_v20.TransactionHeartbeat`)
140 |         """
141 |         pass
142 | 


--------------------------------------------------------------------------------
/async_v20/interface/user.py:
--------------------------------------------------------------------------------
 1 | from .decorators import endpoint
 2 | from ..endpoints.annotations import UserSpecifier
 3 | from ..endpoints.user import *
 4 | 
 5 | __all__ = ['UserInterface']
 6 | 
 7 | 
 8 | class UserInterface(object):
 9 |     @endpoint(GETUserSpecifier)
10 |     def get_user_info(self, user_specifier: UserSpecifier):
11 |         """
12 |         Fetch the user information for the specified user. This endpoint is
13 |         intended to be used by the user thyself to obtain their own
14 |         information.
15 | 
16 |         Args:
17 | 
18 |             user_specifier: :class:`~async_v20.endpoints.annotations.UserSpecifier`
19 |                 The User Specifier
20 | 
21 |         Returns:
22 | 
23 |             status [200]
24 |                 :class:`~async_v20.interface.response.Response`
25 |                 (userInfo= :class:`~async_v20.UserInfo`)
26 |         """
27 |         pass
28 | 
29 |     @endpoint(GETExternalInfo)
30 |     def get_external_user_info(self, user_specifier: UserSpecifier):
31 |         """
32 |         Fetch the externally-available user information for the specified user.
33 |         This endpoint is intended to be used by 3rd parties that have been
34 |         authorized by a user to view their personal information.
35 | 
36 |         Args:
37 | 
38 |             user_specifier: :class:`~async_v20.endpoints.annotations.UserSpecifier`
39 |                 The User Specifier
40 | 
41 |         Returns:
42 | 
43 |             status [200]
44 |                 :class:`~async_v20.interface.response.Response`
45 |                 (userInfo= :class:`~async_v20.UserInfoExternal`)
46 |         """
47 |         pass
48 | 


--------------------------------------------------------------------------------
/bin/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/bin/__init__.py


--------------------------------------------------------------------------------
/bin/account.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | 
 6 | async def get_account():
 7 |     async with OandaClient() as client:
 8 |         return await client.account()
 9 | 
10 | 
11 | loop = asyncio.get_event_loop()
12 | account = loop.run_until_complete(get_account())
13 | 
14 | # pandas Series
15 | print(account.series())
16 | 
17 | # HTTP response state
18 | print(account)
19 | 
20 | # JSON data in python dictionary format
21 | print(account.dict())
22 | 


--------------------------------------------------------------------------------
/bin/account_changes.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | 
 6 | async def account():
 7 |     async with OandaClient() as client:
 8 |         return await client.account_changes()
 9 | 
10 | 
11 | loop = asyncio.get_event_loop()
12 | response = loop.run_until_complete(account())
13 | 
14 | # HTTP response state
15 | print(response['state'])
16 | 
17 | # JSON data in python dictionary format
18 | print(response['state'].dict())
19 | 
20 | # pandas Series
21 | print(response['state'].series())
22 | 


--------------------------------------------------------------------------------
/bin/candle_data.py:
--------------------------------------------------------------------------------
  1 | """A tool for downloading historical data"""
  2 | 
  3 | import argparse
  4 | import asyncio
  5 | import logging
  6 | from datetime import datetime, timedelta
  7 | from functools import reduce
  8 | 
  9 | from async_v20 import OandaClient
 10 | 
 11 | logger = logging.getLogger('async_v20')
 12 | logger.addHandler(logging.StreamHandler())
 13 | logger.setLevel(logging.INFO)
 14 | 
 15 | parser = argparse.ArgumentParser()
 16 | 
 17 | parser.add_argument('--from-time', help='The date from when to get the date')
 18 | parser.add_argument('--to-time', help='Get the required data up to this date', )
 19 | parser.add_argument('--instrument', help='The instrument of the data to get')
 20 | parser.add_argument('--granularity', help='The width of the candle to get')
 21 | parser.add_argument('--out-file', help='The destination of the data')
 22 | parser.add_argument('--time-out', help='The request time out period', default=30)
 23 | 
 24 | granularity_to_minutes = {
 25 |     'S5': 416,
 26 |     'S10': 833,
 27 |     'S15': 1250,
 28 |     'S30': 2500,
 29 |     'M1': 5000,
 30 |     'M2': 10000,
 31 |     'M4': 20000,
 32 |     'M5': 25000,
 33 |     'M10': 50000,
 34 |     'M15': 75000,
 35 |     'M30': 150000,
 36 |     'H1': 300000,
 37 |     'H2': 600000,
 38 |     'H3': 900000,
 39 |     'H4': 1200000,
 40 |     'H6': 1800000,
 41 |     'H8': 2400000,
 42 |     'H12': 3600000,
 43 |     'D': 7200000,
 44 |     'W': 50400000,
 45 |     'M': 201600000
 46 | }
 47 | 
 48 | 
 49 | def create_requests(client,
 50 |                     instrument_name,
 51 |                     granularity,
 52 |                     from_time,
 53 |                     to_time,
 54 |                     price='MBA',
 55 |                     count=5000):
 56 |     change = timedelta(minutes=granularity_to_minutes[granularity])
 57 |     from_time = from_time
 58 |     while from_time < to_time:
 59 |         yield client.get_candles(instrument_name, price=price, granularity=granularity, count=count,
 60 |                                  from_time=from_time)
 61 |         from_time = from_time + change
 62 | 
 63 | 
 64 | async def worker(coroutines, data_frames):
 65 |     while True:
 66 |         try:
 67 |             coroutine = next(coroutines)
 68 |         except StopIteration:
 69 |             return
 70 |         rsp = await coroutine
 71 |         if not rsp.status == 200:
 72 |             raise ConnectionError(f'Failed Downloading candles. {rsp.json()}')
 73 |         df = rsp.candles.dataframe(datetime_format='UNIX')
 74 |         df.index = df.time
 75 |         data_frames.append(df)
 76 | 
 77 | 
 78 | async def get_data(client, instrument_name, granularity, from_time, to_time):
 79 |     data_frames = []
 80 |     coroutines = create_requests(client, instrument_name, granularity, from_time, to_time)
 81 |     await asyncio.gather(*[worker(coroutines, data_frames) for _ in range(5)])
 82 |     df = reduce(lambda x, y: x.append(y), data_frames)
 83 |     df.sort_index(inplace=True)
 84 |     return df
 85 | 
 86 | 
 87 | async def execute():
 88 |     namespace = parser.parse_args()
 89 |     from_time = datetime(*[int(i) for i in namespace.from_time.split('-')])
 90 |     to_time = datetime(*[int(i) for i in namespace.to_time.split('-')])
 91 |     granularity = namespace.granularity
 92 |     out_file = namespace.out_file
 93 |     time_out = namespace.time_out
 94 |     async with OandaClient(rest_timeout=int(time_out)) as client:
 95 |         df = await get_data(client, namespace.instrument, granularity, from_time, to_time)
 96 |     df.to_csv(out_file)
 97 | 
 98 | 
 99 | loop = asyncio.get_event_loop()
100 | run = loop.run_until_complete
101 | 
102 | loop.run_until_complete(execute())
103 | 


--------------------------------------------------------------------------------
/bin/candles.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | 
 6 | async def candles():
 7 |     async with OandaClient() as client:
 8 |         return await client.get_candles('AUD_USD', granularity='M')
 9 | 
10 | 
11 | loop = asyncio.get_event_loop()
12 | 
13 | response = loop.run_until_complete(candles())
14 | 
15 | # HTTP response state
16 | print(response['instrument'])
17 | 
18 | # JSON data in python dictionary format
19 | print(response['candles'][0].dict())
20 | 
21 | # pandas Series
22 | print(response['candles'][0].series())
23 | 


--------------------------------------------------------------------------------
/bin/check_api_methods.py:
--------------------------------------------------------------------------------
  1 | import asyncio
  2 | from time import time
  3 | import random
  4 | from async_v20 import OandaClient, LastTransactionID, OrderSpecifier, TransactionID, TradeSpecifier
  5 | 
  6 | loop = asyncio.get_event_loop()
  7 | 
  8 | client = OandaClient()
  9 | 
 10 | run = lambda *x: loop.run_until_complete(asyncio.gather(*x))
 11 | 
 12 | 
 13 | print('RUNNING TEST')
 14 | 
 15 | rsp = run(
 16 |     client.account(),
 17 |     client.list_accounts(),
 18 |     client.get_account_details(),
 19 |     client.account_summary(),
 20 |     client.account_instruments(),
 21 |     client.get_candles('AUD_USD'),
 22 |     # should be ok
 23 |     client.account_instruments(instruments='AUD_USD,EUR_USD,AUD_JPY'),
 24 |     # should give error
 25 |     client.account_instruments(instruments='AUD_USD EUR_USD'),
 26 |     # error
 27 |     client.configure_account(margin_rate=200),
 28 |     # ok
 29 |     client.configure_account(margin_rate=20),
 30 |     client.account_changes(),
 31 |     client.get_candles('AUD_USD', price='BMA', count=10, granularity='S5',
 32 |                        daily_alignment=0, include_first_query=False),
 33 |     client.get_candles('AUD_USD', from_time=time() - (60 * 10)),
 34 |     client.get_order_book('AUD_USD'),
 35 |     client.get_position_book('AUD_USD'),
 36 | )
 37 | 
 38 | for i in rsp:
 39 |     print(i.json())
 40 | 
 41 | rsp = run(*[client.create_order('AUD_USD', -11) for _ in range(10)])
 42 | for i in rsp:
 43 |     print(i.json())
 44 | 
 45 | rsp = run(client.list_open_trades())
 46 | 
 47 | for i in rsp:
 48 |     print(i.json())
 49 | 
 50 | rsp = run(client.close_position('AUD_USD', long_units='ALL'))
 51 | 
 52 | for i in rsp:
 53 |     print(i.json())
 54 | 
 55 | rsp = run(*[client.create_order('AUD_USD', 1) for _ in range(10)])
 56 | 
 57 | for i in rsp:
 58 |     print(i.json())
 59 | 
 60 | rsp = run(client.close_position('AUD_USD', long_units='5'))
 61 | 
 62 | for i in rsp:
 63 |     print(i.json())
 64 | 
 65 | rsp = run(client.close_all_trades())
 66 | 
 67 | print(rsp)
 68 | 
 69 | rsp = run(*[client.create_order('AUD_USD', 1) for _ in range(10)],
 70 |           client.list_orders(),
 71 |           client.list_pending_orders())
 72 | 
 73 | for i in rsp:
 74 |     print(i.json())
 75 | 
 76 | rsp = run(client.get_order(OrderSpecifier(client.default_parameters[LastTransactionID])))
 77 | 
 78 | for i in rsp:
 79 |     print(i.json())
 80 | 
 81 | rsp = run(client.create_order('AUD_USD', 10))
 82 | 
 83 | for i in rsp:
 84 |     print(i.json())
 85 | 
 86 | rsp = run(client.limit_order('AUD_USD', 10, 0.5))
 87 | 
 88 | for i in rsp:
 89 |     print(i.json())
 90 | 
 91 | rsp = run(client.cancel_order(order_specifier=OrderSpecifier(client.default_parameters[LastTransactionID])))
 92 | 
 93 | for i in rsp:
 94 |     print(i.json())
 95 | 
 96 | rsp = run(client.market_order('EUR_USD', 1))
 97 | 
 98 | for i in rsp:
 99 |     print(i.json())
100 | 
101 | rsp = run(client.close_all_trades())
102 | 
103 | print(rsp)
104 | 
105 | rsp = run(*[client.create_order('AUD_USD', 1) for _ in range(10)])
106 | 
107 | for i in rsp:
108 |     print(i.json())
109 | 
110 | rsp = run(
111 |     client.list_positions(),
112 |     client.list_open_positions(),
113 |     client.get_position('AUD_USD'),
114 |     client.close_position('AUD_USD', long_units='ALL'),
115 |     client.get_pricing('AUD_USD'),
116 | 
117 | )
118 | 
119 | for i in rsp:
120 |     print(i.json())
121 | 
122 | rsp = run(*[client.create_order('AUD_JPY', 1) for _ in range(10)])
123 | 
124 | for i in rsp:
125 |     print(i.json())
126 | 
127 | rsp = run(
128 |     client.list_open_trades(),
129 |     client.list_trades(),
130 |     client.get_trade(TradeSpecifier(client.default_parameters[LastTransactionID])),
131 |     client.list_transactions(),
132 |     client.get_transaction(TransactionID(client.default_parameters[LastTransactionID])),
133 | 
134 | )
135 | for i in rsp:
136 |     print(i.json())
137 | 
138 | print(run(client.close_all_trades()))
139 | 
140 | # Test rest functionality
141 | 
142 | account = run(client.account())
143 | 
144 | for position in account[0].positions:
145 |     print(position)
146 |     assert position.long.units == 0
147 |     assert position.short.units == 0
148 | 
149 | trades = [client.create_order(instrument=random.choice(
150 |     list(map(lambda x: x.name, client.instruments))), units=1) for
151 |       _ in range(16)]
152 | 
153 | rsp = run(*trades)
154 | 
155 | account = run(client.account())[0]
156 | 
157 | positions = {r.orderCreateTransaction.instrument: 0 for r in rsp
158 |              if hasattr(r, 'orderFillTransaction')}
159 | 
160 | for response in rsp:
161 |     fill = getattr(response, 'orderFillTransaction', None)
162 |     if fill is not None:
163 |         positions[fill.instrument] += fill.units
164 | 
165 | print(positions)
166 | print(account.positions._instrument_index)
167 | print(account.positions._items)
168 | for instrument, units in positions.items():
169 |     assert account.positions.get_instrument(instrument).long.units == units
170 | 
171 | rsp = run(client.list_open_trades())[0]
172 | 
173 | assert len(rsp.trades) == len(account.trades)
174 | 
175 | print(run(client.close_all_trades()))
176 | 
177 | account = run(client.account())[0]
178 | 
179 | assert len(account.trades) == 0, f'Account still has trades open {account.trades}'
180 | run(client.close())
181 | print('TEST SUCCESSFUL!')
182 | 


--------------------------------------------------------------------------------
/bin/concurrent_example.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | client = OandaClient()
 6 | 
 7 | 
 8 | async def poll_account(poll_interval=6, client=client):
 9 |     while True:
10 |         account = await client.account()
11 |         print(account)
12 |         await asyncio.sleep(poll_interval)
13 | 
14 | 
15 | async def stream(instruments, client=client):
16 |     async for price in await client.stream_pricing(instruments):
17 |         print(price)
18 | 
19 | 
20 | loop = asyncio.get_event_loop()
21 | loop.run_until_complete(
22 |     asyncio.gather(poll_account(), stream('EUR_USD'))
23 |     )
24 | client.close()
25 | 


--------------------------------------------------------------------------------
/bin/data_download_tool.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | import asyncio
  3 | import logging
  4 | from datetime import datetime, timedelta
  5 | from functools import reduce
  6 | 
  7 | from async_v20 import OandaClient
  8 | 
  9 | logger = logging.getLogger('async_v20')
 10 | logger.addHandler(logging.StreamHandler())
 11 | logger.setLevel(logging.INFO)
 12 | 
 13 | parser = argparse.ArgumentParser()
 14 | 
 15 | parser.add_argument('--from-time', help='The date from when to get the date')
 16 | parser.add_argument('--to-time', help='Get the required data up to this date', )
 17 | parser.add_argument('--instrument', help='The instrument of the data to get')
 18 | parser.add_argument('--granularity', help='The width of the candle to get')
 19 | parser.add_argument('--out-file', help='The destination of the data')
 20 | 
 21 | granularity_to_minutes = {
 22 |     'S5': 416,
 23 |     'S10': 833,
 24 |     'S15': 1250,
 25 |     'S30': 2500,
 26 |     'M1': 5000,
 27 |     'M2': 10000,
 28 |     'M4': 20000,
 29 |     'M5': 25000,
 30 |     'M10': 50000,
 31 |     'M15': 75000,
 32 |     'M30': 150000,
 33 |     'H1': 300000,
 34 |     'H2': 600000,
 35 |     'H3': 900000,
 36 |     'H4': 1200000,
 37 |     'H6': 1800000,
 38 |     'H8': 2400000,
 39 |     'H12': 3600000,
 40 |     'D': 7200000,
 41 |     'W': 50400000,
 42 |     'M': 201600000
 43 | }
 44 | 
 45 | loop = asyncio.get_event_loop()
 46 | run = loop.run_until_complete
 47 | 
 48 | 
 49 | def rolling(df, window, step):
 50 |     count = 0
 51 |     df_length = len(df)
 52 |     while count < (df_length - window):
 53 |         yield count, df[count:window + count]
 54 |         count += step
 55 | 
 56 | 
 57 | def create_requests(client,
 58 |                     instrument_name,
 59 |                     granularity,
 60 |                     from_time,
 61 |                     to_time,
 62 |                     price='MBA',
 63 |                     count=5000):
 64 |     change = timedelta(minutes=granularity_to_minutes[granularity])
 65 |     from_time = from_time
 66 |     while from_time < to_time:
 67 |         yield client.get_candles(instrument_name, price=price, granularity=granularity, count=count,
 68 |                                  from_time=from_time)
 69 |         from_time = from_time + change
 70 | 
 71 | 
 72 | async def worker(coroutines, data_frames):
 73 |     while True:
 74 |         try:
 75 |             coroutine = next(coroutines)
 76 |         except StopIteration:
 77 |             return
 78 |         rsp = await coroutine
 79 |         if not rsp.status == 200:
 80 |             continue
 81 |         df = rsp.candles.dataframe(datetime_format='UNIX')
 82 |         df.index = df.time
 83 |         data_frames.append(df)
 84 | 
 85 | 
 86 | async def get_data(client, instrument_name, granularity, from_time, to_time):
 87 |     data_frames = []
 88 |     coroutines = create_requests(client, instrument_name, granularity, from_time, to_time)
 89 |     await asyncio.gather(*[worker(coroutines, data_frames) for _ in range(6)])
 90 |     df = reduce(lambda x, y: x.append(y), data_frames)
 91 |     df.sort_index(inplace=True)
 92 |     return df
 93 | 
 94 | 
 95 | async def execute():
 96 |     namespace = parser.parse_args()
 97 |     from_time = datetime(*[int(i) for i in namespace.from_time.split('-')])
 98 |     to_time = datetime(*[int(i) for i in namespace.to_time.split('-')])
 99 |     granularity = namespace.granularity
100 |     out_file = namespace.out_file
101 |     async with OandaClient(rest_timeout=120) as client:
102 |         df = await get_data(client, namespace.instrument, granularity, from_time, to_time)
103 |     df.to_msgpack(out_file)
104 | 
105 | 
106 | loop.run_until_complete(execute())
107 | 


--------------------------------------------------------------------------------
/bin/initialization.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | client = OandaClient()
 6 | 
 7 | loop = asyncio.get_event_loop()
 8 | response = loop.run_until_complete(client.initialize())
 9 | 
10 | # Write your code here
11 | 
12 | loop.run_until_complete(client.close())
13 | 


--------------------------------------------------------------------------------
/bin/passing_arguments.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | client = OandaClient()
 6 | 
 7 | # This
 8 | coroutine_1 = client.create_order('AUD_USD', 10)
 9 | 
10 | # Is the same as this
11 | from async_v20 import InstrumentName, DecimalNumber
12 | 
13 | coroutine_2 = client.create_order(
14 |     InstrumentName('AUD_USD'), DecimalNumber(10)
15 | )
16 | 
17 | # Is the same as this
18 | from async_v20 import OrderRequest
19 | 
20 | coroutine_3 = client.post_order(
21 |     order_request=OrderRequest(
22 |         instrument='AUD_USD', units=10, type='MARKET'
23 |     )
24 | )
25 | 
26 | loop = asyncio.get_event_loop()
27 | loop.run_until_complete(
28 |     asyncio.gather(
29 |         coroutine_1,
30 |         coroutine_2,
31 |         coroutine_3
32 |     )
33 | )
34 | 


--------------------------------------------------------------------------------
/bin/place_order.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | from async_v20.definitions.types import MarketOrderRequest
 5 | 
 6 | # Create an order to place
 7 | order = MarketOrderRequest('AUD_USD', 1)
 8 | 
 9 | 
10 | async def account():
11 |     async with OandaClient() as client:
12 |         return await client.post_order(order_request=order)
13 | 
14 | 
15 | loop = asyncio.get_event_loop()
16 | response = loop.run_until_complete(account())
17 | 
18 | print(response)
19 | 


--------------------------------------------------------------------------------
/bin/poll_account.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | 
 6 | async def poll_account(poll_interval=6):
 7 |     async with OandaClient() as client:
 8 |         while True:
 9 |             account = await client.account()
10 |             print(account)
11 |             await asyncio.sleep(poll_interval)
12 | 
13 | 
14 | loop = asyncio.get_event_loop()
15 | response = loop.run_until_complete(poll_account())
16 | 


--------------------------------------------------------------------------------
/bin/preload.py:
--------------------------------------------------------------------------------
 1 | """Import and setup ready for user interaction"""
 2 | 
 3 | from async_v20 import *
 4 | import asyncio
 5 | import logging
 6 | 
 7 | logger = logging.getLogger('async_v20')
 8 | handler = logging.StreamHandler()
 9 | logger.addHandler(handler)
10 | logger.setLevel(logging.INFO)
11 | 
12 | client = OandaClient(rest_timeout=40)
13 | loop = asyncio.get_event_loop()
14 | run = loop.run_until_complete


--------------------------------------------------------------------------------
/bin/stream_prices.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | 
 6 | async def stream(instruments):
 7 |     async with OandaClient() as client:
 8 |         async for rsp in await client.stream_pricing(instruments):
 9 |             print(rsp.dict(json=True))
10 | 
11 | 
12 | loop = asyncio.get_event_loop()
13 | loop.run_until_complete(stream('AUD_USD,EUR_USD'))
14 | 


--------------------------------------------------------------------------------
/bin/stream_transactions.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | 
 3 | from async_v20 import OandaClient
 4 | 
 5 | 
 6 | async def stream():
 7 |     async with OandaClient() as client:
 8 |         async for rsp in await client.stream_transactions():
 9 |             print(rsp.dict(json=True))
10 | 
11 | 
12 | loop = asyncio.get_event_loop()
13 | loop.run_until_complete(stream())
14 | 


--------------------------------------------------------------------------------
/doc/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line.
 5 | SPHINXOPTS    =
 6 | SPHINXBUILD   = python -msphinx
 7 | SPHINXPROJ    = async_v20
 8 | SOURCEDIR     = source
 9 | BUILDDIR      = build
10 | 
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 | 
15 | .PHONY: help Makefile
16 | 
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)


--------------------------------------------------------------------------------
/doc/build/doctrees/api.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/doctrees/api.doctree


--------------------------------------------------------------------------------
/doc/build/doctrees/environment.pickle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/doctrees/environment.pickle


--------------------------------------------------------------------------------
/doc/build/doctrees/glossary.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/doctrees/glossary.doctree


--------------------------------------------------------------------------------
/doc/build/doctrees/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/doctrees/index.doctree


--------------------------------------------------------------------------------
/doc/build/html/.buildinfo:
--------------------------------------------------------------------------------
1 | # Sphinx build info version 1
2 | # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
3 | config: e477d6c6b98d82b74f18ca4f79ca2a26
4 | tags: 645f666f9bcd5a90fca523b33c5a78b7
5 | 


--------------------------------------------------------------------------------
/doc/build/html/_sources/api.rst.txt:
--------------------------------------------------------------------------------
  1 | .. _api-docs:
  2 | 
  3 | OandaClient API
  4 | ===============
  5 | 
  6 | .. note::
  7 | 
  8 |       OandaClient will look for OANDA_TOKEN in the enviroment variables
  9 |       if no token is passed
 10 | 
 11 | .. _OandaClient:
 12 | 
 13 | OandaClient
 14 | -----------
 15 | 
 16 | .. autoclass:: async_v20.OandaClient
 17 | 
 18 | Account
 19 | -------
 20 | 
 21 | .. _account:
 22 | .. automethod:: async_v20.OandaClient.account
 23 | .. automethod:: async_v20.OandaClient.list_accounts
 24 | .. automethod:: async_v20.OandaClient.get_account_details
 25 | .. automethod:: async_v20.OandaClient.account_summary
 26 | .. automethod:: async_v20.OandaClient.account_instruments
 27 | .. automethod:: async_v20.OandaClient.configure_account
 28 | .. automethod:: async_v20.OandaClient.account_changes
 29 | 
 30 | Instrument
 31 | ----------
 32 | 
 33 | .. automethod:: async_v20.OandaClient.get_candles
 34 | .. automethod:: async_v20.OandaClient.get_order_book
 35 | .. automethod:: async_v20.OandaClient.get_position_book
 36 | 
 37 | Order
 38 | -----
 39 | 
 40 | .. automethod:: async_v20.OandaClient.post_order
 41 | .. automethod:: async_v20.OandaClient.create_order
 42 | .. automethod:: async_v20.OandaClient.list_orders
 43 | .. automethod:: async_v20.OandaClient.list_pending_orders
 44 | .. automethod:: async_v20.OandaClient.get_order
 45 | .. automethod:: async_v20.OandaClient.replace_order
 46 | .. automethod:: async_v20.OandaClient.cancel_order
 47 | .. automethod:: async_v20.OandaClient.set_client_extensions
 48 | .. automethod:: async_v20.OandaClient.market_order
 49 | .. automethod:: async_v20.OandaClient.limit_order
 50 | .. automethod:: async_v20.OandaClient.limit_replace_order
 51 | .. automethod:: async_v20.OandaClient.stop_order
 52 | .. automethod:: async_v20.OandaClient.stop_replace_order
 53 | .. automethod:: async_v20.OandaClient.market_if_touched_order
 54 | .. automethod:: async_v20.OandaClient.market_if_touched_replace_order
 55 | .. automethod:: async_v20.OandaClient.take_profit_order
 56 | .. automethod:: async_v20.OandaClient.take_profit_replace_order
 57 | .. automethod:: async_v20.OandaClient.stop_loss_order
 58 | .. automethod:: async_v20.OandaClient.stop_loss_replace_order
 59 | .. automethod:: async_v20.OandaClient.trailing_stop_loss_order
 60 | .. automethod:: async_v20.OandaClient.trailing_stop_loss_replace_order
 61 | 
 62 | 
 63 | Position
 64 | --------
 65 | 
 66 | .. automethod:: async_v20.OandaClient.list_positions
 67 | .. automethod:: async_v20.OandaClient.list_open_positions
 68 | .. automethod:: async_v20.OandaClient.get_position
 69 | .. automethod:: async_v20.OandaClient.close_position
 70 | 
 71 | Pricing
 72 | -------
 73 | 
 74 | .. automethod:: async_v20.OandaClient.get_pricing
 75 | .. automethod:: async_v20.OandaClient.stream_pricing
 76 | 
 77 | Trade
 78 | -----
 79 | 
 80 | .. automethod:: async_v20.OandaClient.list_trades
 81 | .. automethod:: async_v20.OandaClient.list_open_trades
 82 | .. automethod:: async_v20.OandaClient.get_trade
 83 | .. automethod:: async_v20.OandaClient.close_trade
 84 | .. _close_all_trades:
 85 | .. automethod:: async_v20.OandaClient.close_all_trades
 86 | .. automethod:: async_v20.OandaClient.set_client_extensions_trade
 87 | .. automethod:: async_v20.OandaClient.set_dependent_orders_trade
 88 | 
 89 | Transaction
 90 | -----------
 91 | 
 92 | .. automethod:: async_v20.OandaClient.list_transactions
 93 | .. automethod:: async_v20.OandaClient.get_transaction
 94 | .. automethod:: async_v20.OandaClient.transaction_range
 95 | .. automethod:: async_v20.OandaClient.since_transaction
 96 | .. automethod:: async_v20.OandaClient.stream_transactions
 97 | 
 98 | User
 99 | ----
100 | 
101 | .. automethod:: async_v20.OandaClient.get_user_info
102 | .. automethod:: async_v20.OandaClient.get_external_user_info
103 | 
104 | .. _health:
105 | 
106 | Health
107 | ------
108 | 
109 | .. automethod:: async_v20.OandaClient.get_current_event
110 | .. automethod:: async_v20.OandaClient.get_event
111 | .. automethod:: async_v20.OandaClient.get_service
112 | .. automethod:: async_v20.OandaClient.get_service_list
113 | .. automethod:: async_v20.OandaClient.get_status
114 | .. automethod:: async_v20.OandaClient.list_events
115 | .. automethod:: async_v20.OandaClient.list_images
116 | .. automethod:: async_v20.OandaClient.list_service_lists
117 | .. automethod:: async_v20.OandaClient.list_services
118 | .. automethod:: async_v20.OandaClient.list_statuses


--------------------------------------------------------------------------------
/doc/build/html/_sources/glossary.rst.txt:
--------------------------------------------------------------------------------
  1 | .. _glossary:
  2 | 
  3 | 
  4 | ==========
  5 |  Glossary
  6 | ==========
  7 | 
  8 | .. if you add new entries, keep the alphabetical sorting!
  9 | 
 10 | .. glossary::
 11 |    :sorted:
 12 | 
 13 |    aiohttp
 14 | 
 15 |       http client/server framework :term:`async_v20` use's to communicate asynchronously.
 16 | 
 17 |       http://aiohttp.readthedocs.io/en/stable/
 18 | 
 19 |    aiodns
 20 | 
 21 |       An python package for asynchronous DNS resolution.
 22 | 
 23 |       https://github.com/saghul/aiodns
 24 | 
 25 |    asyncio
 26 | 
 27 |       The library for writing single-threaded concurrent code using
 28 |       coroutines, multiplexing I/O access over sockets and other
 29 |       resources, running network clients and servers, and other
 30 |       related primitives.
 31 | 
 32 |       Reference implementation of :pep:`3156`
 33 | 
 34 |       https://pypi.python.org/pypi/asyncio/
 35 | 
 36 |    async_v20
 37 | 
 38 |       The name of the package this documentation is documenting
 39 | 
 40 |       https://github.com/jamespeterschinner/async_v20
 41 | 
 42 |    annotation
 43 | 
 44 |       Used to describe what :term:`type` an argument takes
 45 | 
 46 |       https://www.python.org/dev/peps/pep-0526/
 47 | 
 48 |    attribute
 49 | 
 50 |       An attribute is the term used to describe variables associated with a :term:`class`
 51 |       that contains information about that class' state.
 52 | 
 53 |    attributes
 54 | 
 55 |       plural of :term:`attribute`
 56 | 
 57 |    arguments
 58 | 
 59 |       are values passed to a function
 60 | 
 61 |    await
 62 | 
 63 |       Python syntax to execute a :term:`coroutine` inside an asynchronous function
 64 | 
 65 |    callable
 66 | 
 67 |       Any object that can be called. Use :func:`callable` to check
 68 |       that.
 69 | 
 70 |    camelCase
 71 | 
 72 |       A style of text that uses capital letters to separate words
 73 | 
 74 |    cchardet
 75 | 
 76 | 
 77 |        cChardet is high speed universal character encoding detector -
 78 |        binding to charsetdetect.
 79 | 
 80 |        https://pypi.python.org/pypi/cchardet/
 81 | 
 82 |    class
 83 | 
 84 |       Classes provide a means of bundling data and functionality together.
 85 |       Creating a new class creates a new type of object, allowing new instances of that type to be made.
 86 |       Each class instance can have attributes attached to it for maintaining its state.
 87 |       Class instances can also have methods (defined by its class) for modifying its state.
 88 | 
 89 |       https://docs.python.org/3/tutorial/classes.html
 90 | 
 91 |    concurrent
 92 | 
 93 |       The process by which a single threaded application switches between
 94 |       different tasks. Typically done to prevent waiting for I/O bound operations
 95 | 
 96 |    coroutine
 97 | 
 98 |       A python object that supports asynchronous execution
 99 | 
100 |    coroutines
101 | 
102 |       plural of :term:`coroutine`
103 | 
104 |    context manager
105 | 
106 |       A Python programming concept that defines `enter` and `exit` methods. Used to handle set-up
107 |       and tear-down tasks
108 | 
109 |    docstring
110 | 
111 |       text placed below a function or class definition that documents the function or class
112 | 
113 |       https://www.python.org/dev/peps/pep-0257/
114 | 
115 |    environment variable
116 | 
117 |       An environment variable is a dynamic-named value that can affect the way running processes
118 |       will behave on a computer. They are part of the environment in which a process runs
119 | 
120 | 
121 |    http
122 | 
123 |       Stands for Hyper Text Transfer Protocol
124 | 
125 |       https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol
126 | 
127 |    JSON
128 | 
129 |       JavaScript Object Notation
130 | 
131 |       http://www.json.org/
132 | 
133 |    key
134 | 
135 |        The value used to index a dictionary
136 | 
137 |    metaclass
138 | 
139 |       A python :term:`class` definition that inherits from `type`.
140 |       It allows programmers to customize class creation as if they typed the entire class
141 | 
142 |       https://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
143 | 
144 |    OANDA
145 | 
146 |       The name of the Foreign Exchange (FOREX) broker :term:`async_v20` communicates with
147 | 
148 |    OandaClient
149 | 
150 |       The client class definition :term:`async_v20` exposes
151 | 
152 |    pandas
153 | 
154 |       a Python package providing fast, flexible, and expressive data structures
155 |       designed to make working with "relational" or "labeled" data both easy and intuitive
156 | 
157 |       http://pandas.pydata.org/
158 | 
159 |    python
160 | 
161 |       Programming language
162 | 
163 |       https://www.python.org/
164 | 
165 |    snake_case
166 | 
167 |       a style of text that uses underscores to separate words
168 | 
169 |    status
170 | 
171 |       When prefixed with http. Refers to a 3 digit number with pre-assigned meaning.
172 | 
173 |       https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Status_codes
174 | 
175 |    token
176 | 
177 |       A 65 character string used to uniquely identify and authorise access to the OANDA v20 API
178 | 
179 |       Example:
180 |          `810492ace47473fa9f72c0eeecd33657-1eae8a55f01431bdd370206f69071e5f`
181 | 
182 |    type
183 | 
184 |       In computer science and computer programming,
185 |       a data type or simply type is a classification of data which tells the compiler or
186 |       interpreter how the programmer intends to use the data.
187 | 
188 |       https://en.wikipedia.org/wiki/Data_type
189 | 
190 |    virtual environment
191 | 
192 |       A self-contained directory tree that contains a Python installation for a particular version of Python,
193 |       plus a number of additional packages.
194 | 
195 |       https://docs.python.org/3/tutorial/venv.html


--------------------------------------------------------------------------------
/doc/build/html/_sources/index.rst.txt:
--------------------------------------------------------------------------------
  1 | .. _async_v20-home:
  2 | 
  3 | 
  4 | async_v20: Asynchronous OANDA v20 client
  5 | ========================================
  6 |     *A foreign exchange client*
  7 | 
  8 | .. image:: https://raw.githubusercontent.com/jamespeterschinner/async_v20/master/doc/source/_static/async_v20-icon-128x128.png
  9 |     :alt: async-v20 logo
 10 | 
 11 | .. image:: https://travis-ci.org/jamespeterschinner/async_v20.svg?branch=master
 12 |   :target: https://travis-ci.org/jamespeterschinner/async_v20
 13 | 
 14 | 
 15 | .. image:: https://codecov.io/gh/jamespeterschinner/async_v20/branch/master/graph/badge.svg
 16 |   :target: https://codecov.io/gh/jamespeterschinner/async_v20
 17 | 
 18 | 
 19 | .. image:: https://readthedocs.org/projects/async-v20/badge/?version=latest
 20 |   :target: http://async-v20.readthedocs.io/en/latest/?badge=latest
 21 |   :alt: Documentation Status
 22 | 
 23 | Disclaimer
 24 | ----------
 25 | 
 26 | - **Losses can exceed investment.**
 27 | - async_v20 and its creator has no affiliation with OANDA. And is not endorsed by OANDA in any manner.
 28 | - async_v20 is in Beta stage and has not been tested on a live OANDA account
 29 | - **Use at own risk**
 30 | 
 31 | Features
 32 | ---------
 33 | 
 34 | - Exposes the entire `v20 API <http://developer.oanda.com/rest-live-v20/introduction/>`_ `
 35 | - immutable objects
 36 | - No `*args, **kwargs` In client methods. So no guessing what arguments a method takes
 37 | - Serialize objects directly into *pandas* **Series** or **DataFrame** objects
 38 | - Construct :term:`concurrent` trading algorithms
 39 | 
 40 | .. _installation:
 41 | 
 42 | installation
 43 | ------------
 44 | 
 45 | .. code-block:: bash
 46 | 
 47 |    $ pip install async_v20
 48 | 
 49 | :term:`async_v20` is built with `aiohttp <https://github.com/aio-libs/aiohttp>`_.
 50 | It is therefore recommended to also install :term:`cchardet` and :term:`aiodns` as per :term:`aiohttp`
 51 | `documentation <http://aiohttp.readthedocs.io/en/stable/>`_ `
 52 | 
 53 | .. code-block:: bash
 54 | 
 55 |    $ pip install cchardet
 56 | 
 57 |    $ pip install aiodns
 58 | 
 59 | Why async_v20?
 60 | --------------
 61 | 
 62 | There are many OANDA clients for python already available so why create another?
 63 | The main driver for creating async_v20 was to facilitate better risk management,
 64 | by allowing user's to concurrently monitor account status and trade currency's.
 65 | 
 66 | An unintended consequence of async_v20 is the ability to create clear segregation
 67 | between implementation ideas.
 68 | 
 69 | A simple example might contain a coroutine for the following:
 70 | 
 71 |     - Monitoring overall account status
 72 |     - Watching price stream and triggering buy/sell signals
 73 |     - Monitoring individual trades and closing movements against held positions
 74 | 
 75 | A synchronous implementation would require considerable effort to determine which
 76 | task communicates with the server next. async_v20 removes this burden by using
 77 | `aiohttp <https://github.com/aio-libs/aiohttp>`_
 78 | 
 79 | Further goals of async_v20 has been to lower the barrier of entry for algorithmic trading
 80 | by providing a complete and simple to use interface.
 81 | 
 82 | Tutorial
 83 | --------
 84 | 
 85 | :ref:`tutorial`
 86 | 
 87 | Source code
 88 | -----------
 89 | 
 90 | Can be found on `GitHub <https://github.com/jamespeterschinner/async_v20>`_
 91 | 
 92 | Please feel free to file an issue on the bug tracker if you have found a bug
 93 | or have some suggestion in order to improve the client.
 94 | 
 95 | 
 96 | Dependencies
 97 | ------------
 98 | 
 99 | - **python >= 3.6**
100 | - aiohttp >= 2.2.5
101 | - ujson >= 1.35'
102 | - yarl >= 0.12.0'
103 | - pandas
104 | 
105 | Contents
106 | --------
107 | .. toctree::
108 | 
109 |    getting_started
110 |    best_practices
111 |    beyond_getting_started
112 |    order_request_formatting
113 |    datetimes
114 |    health
115 |    traps
116 |    api
117 |    response
118 |    particularly_pertinent
119 |    types
120 |    primitives
121 |    annotations
122 |    exceptions
123 |    logging
124 |    glossary
125 | 
126 | 


--------------------------------------------------------------------------------
/doc/build/html/_static/ajax-loader.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/ajax-loader.gif


--------------------------------------------------------------------------------
/doc/build/html/_static/comment-bright.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/comment-bright.png


--------------------------------------------------------------------------------
/doc/build/html/_static/comment-close.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/comment-close.png


--------------------------------------------------------------------------------
/doc/build/html/_static/comment.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/comment.png


--------------------------------------------------------------------------------
/doc/build/html/_static/down-pressed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/down-pressed.png


--------------------------------------------------------------------------------
/doc/build/html/_static/down.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/down.png


--------------------------------------------------------------------------------
/doc/build/html/_static/file.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/file.png


--------------------------------------------------------------------------------
/doc/build/html/_static/minus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/minus.png


--------------------------------------------------------------------------------
/doc/build/html/_static/plus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/plus.png


--------------------------------------------------------------------------------
/doc/build/html/_static/pygments.css:
--------------------------------------------------------------------------------
 1 | .highlight .hll { background-color: #ffffcc }
 2 | .highlight  { background: #eeffcc; }
 3 | .highlight .c { color: #408090; font-style: italic } /* Comment */
 4 | .highlight .err { border: 1px solid #FF0000 } /* Error */
 5 | .highlight .k { color: #007020; font-weight: bold } /* Keyword */
 6 | .highlight .o { color: #666666 } /* Operator */
 7 | .highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
 8 | .highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
 9 | .highlight .cp { color: #007020 } /* Comment.Preproc */
10 | .highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
11 | .highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
12 | .highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
13 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
14 | .highlight .ge { font-style: italic } /* Generic.Emph */
15 | .highlight .gr { color: #FF0000 } /* Generic.Error */
16 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
17 | .highlight .gi { color: #00A000 } /* Generic.Inserted */
18 | .highlight .go { color: #333333 } /* Generic.Output */
19 | .highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
20 | .highlight .gs { font-weight: bold } /* Generic.Strong */
21 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
22 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
23 | .highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
24 | .highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
25 | .highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
26 | .highlight .kp { color: #007020 } /* Keyword.Pseudo */
27 | .highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
28 | .highlight .kt { color: #902000 } /* Keyword.Type */
29 | .highlight .m { color: #208050 } /* Literal.Number */
30 | .highlight .s { color: #4070a0 } /* Literal.String */
31 | .highlight .na { color: #4070a0 } /* Name.Attribute */
32 | .highlight .nb { color: #007020 } /* Name.Builtin */
33 | .highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
34 | .highlight .no { color: #60add5 } /* Name.Constant */
35 | .highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
36 | .highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
37 | .highlight .ne { color: #007020 } /* Name.Exception */
38 | .highlight .nf { color: #06287e } /* Name.Function */
39 | .highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
40 | .highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
41 | .highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
42 | .highlight .nv { color: #bb60d5 } /* Name.Variable */
43 | .highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
44 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
45 | .highlight .mb { color: #208050 } /* Literal.Number.Bin */
46 | .highlight .mf { color: #208050 } /* Literal.Number.Float */
47 | .highlight .mh { color: #208050 } /* Literal.Number.Hex */
48 | .highlight .mi { color: #208050 } /* Literal.Number.Integer */
49 | .highlight .mo { color: #208050 } /* Literal.Number.Oct */
50 | .highlight .sa { color: #4070a0 } /* Literal.String.Affix */
51 | .highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
52 | .highlight .sc { color: #4070a0 } /* Literal.String.Char */
53 | .highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
54 | .highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
55 | .highlight .s2 { color: #4070a0 } /* Literal.String.Double */
56 | .highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
57 | .highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
58 | .highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
59 | .highlight .sx { color: #c65d09 } /* Literal.String.Other */
60 | .highlight .sr { color: #235388 } /* Literal.String.Regex */
61 | .highlight .s1 { color: #4070a0 } /* Literal.String.Single */
62 | .highlight .ss { color: #517918 } /* Literal.String.Symbol */
63 | .highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
64 | .highlight .fm { color: #06287e } /* Name.Function.Magic */
65 | .highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
66 | .highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
67 | .highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
68 | .highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
69 | .highlight .il { color: #208050 } /* Literal.Number.Integer.Long */


--------------------------------------------------------------------------------
/doc/build/html/_static/up-pressed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/up-pressed.png


--------------------------------------------------------------------------------
/doc/build/html/_static/up.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/_static/up.png


--------------------------------------------------------------------------------
/doc/build/html/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/build/html/objects.inv


--------------------------------------------------------------------------------
/doc/build/html/search.html:
--------------------------------------------------------------------------------
  1 | 
  2 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  3 |   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  4 | 
  5 | <html xmlns="http://www.w3.org/1999/xhtml">
  6 |   <head>
  7 |     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  8 |     <title>Search &#8212; async_v20 8.0.0b1 documentation</title>
  9 |     <link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
 10 |     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
 11 |     <script type="text/javascript">
 12 |       var DOCUMENTATION_OPTIONS = {
 13 |         URL_ROOT:    './',
 14 |         VERSION:     '8.0.0b1',
 15 |         COLLAPSE_INDEX: false,
 16 |         FILE_SUFFIX: '.html',
 17 |         HAS_SOURCE:  true,
 18 |         SOURCELINK_SUFFIX: '.txt'
 19 |       };
 20 |     </script>
 21 |     <script type="text/javascript" src="_static/jquery.js"></script>
 22 |     <script type="text/javascript" src="_static/underscore.js"></script>
 23 |     <script type="text/javascript" src="_static/doctools.js"></script>
 24 |     <script type="text/javascript" src="_static/searchtools.js"></script>
 25 |     <link rel="index" title="Index" href="genindex.html" />
 26 |     <link rel="search" title="Search" href="#" />
 27 |   <script type="text/javascript">
 28 |     jQuery(function() { Search.loadIndex("searchindex.js"); });
 29 |   </script>
 30 |   
 31 |   <script type="text/javascript" id="searchindexloader"></script>
 32 |   
 33 |    
 34 |   <link rel="stylesheet" href="_static/custom.css" type="text/css" />
 35 |   
 36 |   
 37 |   <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
 38 | 
 39 | 
 40 |   </head>
 41 |   <body>
 42 |   
 43 | 
 44 |     <div class="document">
 45 |       <div class="documentwrapper">
 46 |         <div class="bodywrapper">
 47 |           <div class="body" role="main">
 48 |             
 49 |   <h1 id="search-documentation">Search</h1>
 50 |   <div id="fallback" class="admonition warning">
 51 |   <script type="text/javascript">$('#fallback').hide();</script>
 52 |   <p>
 53 |     Please activate JavaScript to enable the search
 54 |     functionality.
 55 |   </p>
 56 |   </div>
 57 |   <p>
 58 |     From here you can search these documents. Enter your search
 59 |     words into the box below and click "search". Note that the search
 60 |     function will automatically search for all of the words. Pages
 61 |     containing fewer words won't appear in the result list.
 62 |   </p>
 63 |   <form action="" method="get">
 64 |     <input type="text" name="q" value="" />
 65 |     <input type="submit" value="search" />
 66 |     <span id="search-progress" style="padding-left: 10px"></span>
 67 |   </form>
 68 |   
 69 |   <div id="search-results">
 70 |   
 71 |   </div>
 72 | 
 73 |           </div>
 74 |         </div>
 75 |       </div>
 76 |       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
 77 |         <div class="sphinxsidebarwrapper">
 78 | <h1 class="logo"><a href="index.html">async_v20</a></h1>
 79 | 
 80 | 
 81 | 
 82 | 
 83 | 
 84 | 
 85 | 
 86 | 
 87 | <h3>Navigation</h3>
 88 | <ul>
 89 | <li class="toctree-l1"><a class="reference internal" href="getting_started.html">Getting started</a></li>
 90 | <li class="toctree-l1"><a class="reference internal" href="best_practices.html">Best Practices</a></li>
 91 | <li class="toctree-l1"><a class="reference internal" href="beyond_getting_started.html">Beyond Getting Started</a></li>
 92 | <li class="toctree-l1"><a class="reference internal" href="order_request_formatting.html">Formatting Order Requests</a></li>
 93 | <li class="toctree-l1"><a class="reference internal" href="datetimes.html">Dealing With Time</a></li>
 94 | <li class="toctree-l1"><a class="reference internal" href="health.html">Health API</a></li>
 95 | <li class="toctree-l1"><a class="reference internal" href="traps.html">Traps for young players</a></li>
 96 | <li class="toctree-l1"><a class="reference internal" href="api.html">OandaClient API</a></li>
 97 | <li class="toctree-l1"><a class="reference internal" href="response.html">The Response Object</a></li>
 98 | <li class="toctree-l1"><a class="reference internal" href="particularly_pertinent.html">Particularly Pertinent Programming Interface</a></li>
 99 | <li class="toctree-l1"><a class="reference internal" href="types.html">Class Definitions</a></li>
100 | <li class="toctree-l1"><a class="reference internal" href="primitives.html">Primitives</a></li>
101 | <li class="toctree-l1"><a class="reference internal" href="annotations.html">Annotations</a></li>
102 | <li class="toctree-l1"><a class="reference internal" href="exceptions.html">Exceptions</a></li>
103 | <li class="toctree-l1"><a class="reference internal" href="exceptions.html#warnings">Warnings</a></li>
104 | <li class="toctree-l1"><a class="reference internal" href="logging.html">Logging</a></li>
105 | <li class="toctree-l1"><a class="reference internal" href="glossary.html">Glossary</a></li>
106 | </ul>
107 | 
108 | <div class="relations">
109 | <h3>Related Topics</h3>
110 | <ul>
111 |   <li><a href="index.html">Documentation overview</a><ul>
112 |   </ul></li>
113 | </ul>
114 | </div>
115 |         </div>
116 |       </div>
117 |       <div class="clearer"></div>
118 |     </div>
119 |     <div class="footer">
120 |       &copy;2017, James Peter Schinner.
121 |       
122 |       |
123 |       Powered by <a href="http://sphinx-doc.org/">Sphinx 1.6.5</a>
124 |       &amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.10</a>
125 |       
126 |     </div>
127 | 
128 |     
129 | 
130 |     
131 |   </body>
132 | </html>


--------------------------------------------------------------------------------
/doc/make.bat:
--------------------------------------------------------------------------------
 1 | @ECHO OFF
 2 | 
 3 | pushd %~dp0
 4 | 
 5 | REM Command file for Sphinx documentation
 6 | 
 7 | if "%SPHINXBUILD%" == "" (
 8 | 	set SPHINXBUILD=python -msphinx
 9 | )
10 | set SOURCEDIR=source
11 | set BUILDDIR=build
12 | set SPHINXPROJ=async_v20
13 | 
14 | if "%1" == "" goto help
15 | 
16 | %SPHINXBUILD% >NUL 2>NUL
17 | if errorlevel 9009 (
18 | 	echo.
19 | 	echo.The Sphinx module was not found. Make sure you have Sphinx installed,
20 | 	echo.then set the SPHINXBUILD environment variable to point to the full
21 | 	echo.path of the 'sphinx-build' executable. Alternatively you may add the
22 | 	echo.Sphinx directory to PATH.
23 | 	echo.
24 | 	echo.If you don't have Sphinx installed, grab it from
25 | 	echo.http://sphinx-doc.org/
26 | 	exit /b 1
27 | )
28 | 
29 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
30 | goto end
31 | 
32 | :help
33 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
34 | 
35 | :end
36 | popd
37 | 


--------------------------------------------------------------------------------
/doc/source/_static/async_v20-icon-128x128.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/doc/source/_static/async_v20-icon-128x128.png


--------------------------------------------------------------------------------
/doc/source/annotations.rst:
--------------------------------------------------------------------------------
 1 | Annotations
 2 | ===========
 3 | 
 4 | .. note::
 5 |     The class' in :mod:`async_v20.endpoints.annotations`
 6 |     are used as parameter annotations for some :ref:`api-docs` calls,
 7 |     in order to correctly map passed arguments to the correct endpoint
 8 |     parameter
 9 | 
10 | .. autoclass:: async_v20.endpoints.annotations.Alias
11 | .. autoclass:: async_v20.endpoints.annotations.AlignmentTimezone
12 | .. autoclass:: async_v20.endpoints.annotations.Authorization
13 | .. autoclass:: async_v20.endpoints.annotations.Bool
14 | .. autoclass:: async_v20.endpoints.annotations.Count
15 | .. autoclass:: async_v20.endpoints.annotations.DailyAlignment
16 | .. autoclass:: async_v20.endpoints.annotations.End
17 | .. autoclass:: async_v20.endpoints.annotations.EventSid
18 | .. autoclass:: async_v20.endpoints.annotations.FromTime
19 | .. autoclass:: async_v20.endpoints.annotations.FromTransactionID
20 | .. autoclass:: async_v20.endpoints.annotations.Ids
21 | .. autoclass:: async_v20.endpoints.annotations.IncludeFirstQuery
22 | .. autoclass:: async_v20.endpoints.annotations.Instruments
23 | .. autoclass:: async_v20.endpoints.annotations.LastTransactionID
24 | .. autoclass:: async_v20.endpoints.annotations.LongClientExtensions
25 | .. autoclass:: async_v20.endpoints.annotations.LongUnits
26 | .. autoclass:: async_v20.endpoints.annotations.PageSize
27 | .. autoclass:: async_v20.endpoints.annotations.ServiceID
28 | .. autoclass:: async_v20.endpoints.annotations.ServiceListID
29 | .. autoclass:: async_v20.endpoints.annotations.ShortClientExtensions
30 | .. autoclass:: async_v20.endpoints.annotations.ShortUnits
31 | .. autoclass:: async_v20.endpoints.annotations.SinceTransactionID
32 | .. autoclass:: async_v20.endpoints.annotations.Smooth
33 | .. autoclass:: async_v20.endpoints.annotations.Snapshot
34 | .. autoclass:: async_v20.endpoints.annotations.Start
35 | .. autoclass:: async_v20.endpoints.annotations.StatusID
36 | .. autoclass:: async_v20.endpoints.annotations.ToTime
37 | .. autoclass:: async_v20.endpoints.annotations.ToTransactionID
38 | .. autoclass:: async_v20.endpoints.annotations.TradeClientExtensions
39 | .. autoclass:: async_v20.endpoints.annotations.Type
40 | .. autoclass:: async_v20.endpoints.annotations.Units
41 | .. autoclass:: async_v20.endpoints.annotations.UserSpecifier


--------------------------------------------------------------------------------
/doc/source/api.rst:
--------------------------------------------------------------------------------
  1 | .. _api-docs:
  2 | 
  3 | OandaClient API
  4 | ===============
  5 | 
  6 | .. note::
  7 | 
  8 |       OandaClient will look for OANDA_TOKEN in the enviroment variables
  9 |       if no token is passed
 10 | 
 11 | .. _OandaClient:
 12 | 
 13 | OandaClient
 14 | -----------
 15 | 
 16 | .. autoclass:: async_v20.OandaClient
 17 | 
 18 | Account
 19 | -------
 20 | 
 21 | .. _account:
 22 | .. automethod:: async_v20.OandaClient.account
 23 | .. automethod:: async_v20.OandaClient.list_accounts
 24 | .. automethod:: async_v20.OandaClient.get_account_details
 25 | .. automethod:: async_v20.OandaClient.account_summary
 26 | .. automethod:: async_v20.OandaClient.account_instruments
 27 | .. automethod:: async_v20.OandaClient.configure_account
 28 | .. automethod:: async_v20.OandaClient.account_changes
 29 | 
 30 | Instrument
 31 | ----------
 32 | 
 33 | .. automethod:: async_v20.OandaClient.get_candles
 34 | .. automethod:: async_v20.OandaClient.get_order_book
 35 | .. automethod:: async_v20.OandaClient.get_position_book
 36 | 
 37 | Order
 38 | -----
 39 | 
 40 | .. automethod:: async_v20.OandaClient.post_order
 41 | .. automethod:: async_v20.OandaClient.create_order
 42 | .. automethod:: async_v20.OandaClient.list_orders
 43 | .. automethod:: async_v20.OandaClient.list_pending_orders
 44 | .. automethod:: async_v20.OandaClient.get_order
 45 | .. automethod:: async_v20.OandaClient.replace_order
 46 | .. automethod:: async_v20.OandaClient.cancel_order
 47 | .. automethod:: async_v20.OandaClient.set_client_extensions
 48 | .. automethod:: async_v20.OandaClient.market_order
 49 | .. automethod:: async_v20.OandaClient.limit_order
 50 | .. automethod:: async_v20.OandaClient.limit_replace_order
 51 | .. automethod:: async_v20.OandaClient.stop_order
 52 | .. automethod:: async_v20.OandaClient.stop_replace_order
 53 | .. automethod:: async_v20.OandaClient.market_if_touched_order
 54 | .. automethod:: async_v20.OandaClient.market_if_touched_replace_order
 55 | .. automethod:: async_v20.OandaClient.take_profit_order
 56 | .. automethod:: async_v20.OandaClient.take_profit_replace_order
 57 | .. automethod:: async_v20.OandaClient.stop_loss_order
 58 | .. automethod:: async_v20.OandaClient.stop_loss_replace_order
 59 | .. automethod:: async_v20.OandaClient.trailing_stop_loss_order
 60 | .. automethod:: async_v20.OandaClient.trailing_stop_loss_replace_order
 61 | 
 62 | 
 63 | Position
 64 | --------
 65 | 
 66 | .. automethod:: async_v20.OandaClient.list_positions
 67 | .. automethod:: async_v20.OandaClient.list_open_positions
 68 | .. automethod:: async_v20.OandaClient.get_position
 69 | .. automethod:: async_v20.OandaClient.close_position
 70 | 
 71 | Pricing
 72 | -------
 73 | 
 74 | .. automethod:: async_v20.OandaClient.get_pricing
 75 | .. automethod:: async_v20.OandaClient.stream_pricing
 76 | 
 77 | Trade
 78 | -----
 79 | 
 80 | .. automethod:: async_v20.OandaClient.list_trades
 81 | .. automethod:: async_v20.OandaClient.list_open_trades
 82 | .. automethod:: async_v20.OandaClient.get_trade
 83 | .. automethod:: async_v20.OandaClient.close_trade
 84 | .. _close_all_trades:
 85 | .. automethod:: async_v20.OandaClient.close_all_trades
 86 | .. automethod:: async_v20.OandaClient.set_client_extensions_trade
 87 | .. automethod:: async_v20.OandaClient.set_dependent_orders_trade
 88 | 
 89 | Transaction
 90 | -----------
 91 | 
 92 | .. automethod:: async_v20.OandaClient.list_transactions
 93 | .. automethod:: async_v20.OandaClient.get_transaction
 94 | .. automethod:: async_v20.OandaClient.transaction_range
 95 | .. automethod:: async_v20.OandaClient.since_transaction
 96 | .. automethod:: async_v20.OandaClient.stream_transactions
 97 | 
 98 | User
 99 | ----
100 | 
101 | .. automethod:: async_v20.OandaClient.get_user_info
102 | .. automethod:: async_v20.OandaClient.get_external_user_info
103 | 
104 | .. _health:
105 | 
106 | Health
107 | ------
108 | 
109 | .. automethod:: async_v20.OandaClient.get_current_event
110 | .. automethod:: async_v20.OandaClient.get_event
111 | .. automethod:: async_v20.OandaClient.get_service
112 | .. automethod:: async_v20.OandaClient.get_service_list
113 | .. automethod:: async_v20.OandaClient.get_status
114 | .. automethod:: async_v20.OandaClient.list_events
115 | .. automethod:: async_v20.OandaClient.list_images
116 | .. automethod:: async_v20.OandaClient.list_service_lists
117 | .. automethod:: async_v20.OandaClient.list_services
118 | .. automethod:: async_v20.OandaClient.list_statuses


--------------------------------------------------------------------------------
/doc/source/best_practices.rst:
--------------------------------------------------------------------------------
 1 | .. _best-practices:
 2 | 
 3 | Best Practices
 4 | ==============
 5 | 
 6 | One OandaClient per application
 7 | -------------------------------
 8 | 
 9 | :ref:`tutorial` example, used :ref:`OandaClient` as a context manager. This is correct when
10 | the client does not need to be shared between multiple :term:`coroutines`.
11 | 
12 | This is a an example of multiple coroutines using the **One** OandaClient instance:
13 | 
14 | .. literalinclude:: ../../bin/concurrent_example.py
15 |     :emphasize-lines: 5
16 | 
17 | Initialize first
18 | ----------------
19 | 
20 | `OandaClient` requires initialization. The initialization procedure can delay execution of `OandaClient`. **methods**
21 | 
22 | If this is a concern for you, it is recommended to preemptively initialize the OandaClient instance.
23 | 
24 | .. literalinclude:: ../../bin/initialization.py
25 |     :emphasize-lines: 8
26 | 
27 | Check Services
28 | --------------
29 | 
30 | It is encouraged to check the service you wish to consume is available. See :ref:`health_api`.
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/doc/source/beyond_getting_started.rst:
--------------------------------------------------------------------------------
  1 | Beyond Getting Started
  2 | ======================
  3 | 
  4 | So you have read :ref:`tutorial` and need to know more.
  5 | 
  6 | Your first issue is knowing what methods to use.
  7 | 
  8 | The :ref:`api-docs` docs contains all the exposed methods :term:`async_v20` provides.
  9 | 
 10 | What you need to know
 11 | ---------------------
 12 | 
 13 | - :ref:`OandaClient` returns v20 API calls in :class:`~async_v20.interface.response.Response` objects
 14 |     The `response` is a python dictionary and designed to reflect the responses defined by the v20
 15 |     `docs <http://developer.oanda.com/rest-live-v20/introduction/>`_ :
 16 | 
 17 |     - responses contain the equivalent python objects. As defined in :ref:`class-definitions`
 18 | 
 19 | - *OandaClient*. Automatically supplys arguments to endpoints that require the following:
 20 | 
 21 |     .. autoclass:: async_v20.definitions.primitives.AccountID
 22 |         :noindex:
 23 |     .. autoclass:: async_v20.endpoints.annotations.Authorization
 24 |         :noindex:
 25 |     .. autoclass:: async_v20.endpoints.annotations.LastTransactionID
 26 |         :noindex:
 27 |     .. autoclass:: async_v20.endpoints.annotations.SinceTransactionID
 28 |         :noindex:
 29 | 
 30 | 
 31 | - **OandaClient** by default will connect to the practice server:
 32 |     - OANDA's `docs <http://developer.oanda.com/rest-live-v20/introduction/>`_ Contain host information
 33 | 
 34 | 
 35 | Underling Principles
 36 | --------------------
 37 | 
 38 | All arguments passed to :ref:`api-docs` methods are used to create instances of the parameters annotation.
 39 | Why is this useful?
 40 | 
 41 |     - Prevents you from importing required class' and instantiating them manually
 42 |     - HTTP requests are formatted based upon the objects the endpoint accepts. See :ref:`passing-arguments`
 43 |     - The base class :class:`~async_v20.definitions.base.Model` will convert the object into valid :term:`JSON`
 44 |     - Invalid arguments will raise :class:`~async_v20.exceptions.InvalidValue` catching mistakes earlier
 45 |     - Provides flexibility when passing arguments
 46 | 
 47 | Here is an Example
 48 | 
 49 | .. literalinclude:: ../../bin/passing_arguments.py
 50 | 
 51 | .. note::
 52 | 
 53 |     Executing this example **will** create a long position of the AUD/USD currency pair
 54 |     worth 30 units.
 55 | 
 56 | 
 57 | What might be useful
 58 | --------------------
 59 | 
 60 | .. _passing-arguments:
 61 | 
 62 | How Are Arguments Passed
 63 | ________________________
 64 | 
 65 | All methods exposed by *async_v20*. **OandaClient** are written in a declarative fashion.
 66 | 
 67 | Lets take at look at an example:
 68 | 
 69 | .. literalinclude:: ../../async_v20/interface/instrument.py
 70 |     :lines: 19-32
 71 | 
 72 | .. Note::
 73 | 
 74 |     The :term:`docstring` has been left of this example for brevity.
 75 |         - This example is not complete without a `pass` statement
 76 | 
 77 | **First**
 78 |    - We define the endpoint:
 79 | 
 80 |     .. literalinclude:: ../../async_v20/interface/instrument.py
 81 |         :lines: 20
 82 |         :emphasize-lines: 1
 83 | 
 84 | **Then**
 85 |    - We define arguments to pass to the endpoint
 86 | 
 87 | 
 88 |     .. literalinclude:: ../../async_v20/interface/instrument.py
 89 |         :lines: 20-32
 90 |         :emphasize-lines: 2-13
 91 | 
 92 | 
 93 | You will notice that all :term:`arguments` have an :term:`annotation`.
 94 | 
 95 | async_v20 uses these annotations to format arguments into
 96 | the correct http request.
 97 | 
 98 | The http request formatting is defined by the *EndPoint*
 99 | 
100 | **In this case**
101 | 
102 |     .. literalinclude:: ../../async_v20/endpoints/instrument.py
103 |         :lines: 9-33
104 | 
105 | **Notice that**
106 | 
107 |     .. literalinclude:: ../../async_v20/endpoints/instrument.py
108 |         :lines: 20
109 |         :emphasize-lines: 1
110 | 
111 |     Contains :term:`key` entries that coincide with the methods annotations.
112 |     The annotation is then used to lookup up location of the argument in the HTTP request
113 |     and the corresponding key that will be used with the passed data to create the
114 |     correct key/value pair.
115 | 
116 | 
117 | How Responses are Constructed
118 | _____________________________
119 | 
120 | The :term:`http` response from :term:`OANDA` is handled by the `EndPoint`
121 | each *OandaClient*. **method** defines.
122 | 
123 | There is a two step process by which the response is constructed:
124 |    - The http :term:`status` is used to look up the expected response
125 |    - Each JSON object is constructed into the appropriate python object
126 | 
127 | How Objects are Serialized
128 | __________________________
129 | 
130 | One of the main problems :term:`async_v20` solves for you is correctly formatting
131 | `objects` into JSON that OANDA's v20 API accepts.
132 | 
133 | The issue here is that OANDA defines objects with :term:`camelCase` :term:`attributes`.
134 | Python programs typically reserve camelCase for :term:`class` definitions.
135 | 
136 | This means, in order to both satisfy python standards and OANDA,
137 | objects (as defined in :ref:`class-definitions`) need to accept `camelCase` and :term:`snake_case`
138 | arguments when being constructed.
139 | 
140 | `Objects` store there attributes as `snake_case` (as python programmers would expect),
141 | which adds a further requirement to convert these into `camelCase` when being serialized.
142 | 
143 | To solve this the :mod:`async_v20.definitions.attributes` module
144 | contains two dictionaries. :attr:`~async_v20.definitions.attributes.instance_attributes`
145 | & :attr:`~async_v20.definitions.attributes.json_attributes`:
146 | 
147 |    - When creating objects, arguments are passed through `instance_attributes` dictionary
148 |    - When serializing objects, attributes are passed through `json_attributes` dictionary
149 | 
150 | 


--------------------------------------------------------------------------------
/doc/source/datetimes.rst:
--------------------------------------------------------------------------------
  1 | Dealing With Time
  2 | =================
  3 | 
  4 | DateTimes in async_20 have a requirement to support two time formats:
  5 | 
  6 |     - **RFC3339**   - *'2017-08-11T15:04:31.639182000Z'*
  7 |     - **UNIX**      - *'1502463871.639182000'*
  8 | 
  9 | .. note::
 10 |     These are the two valid arguments that may be supplied to :class:`~async_v20.OandaClient`.
 11 | 
 12 | :class:`~async_v20.definitions.primitives.DateTime` is responsible for handling datetimes in async_v20.
 13 | calling **DateTime** with either a *RFC3339*, *UNIX*, time.time(), or datetime.datetime()
 14 | representation of a datetime creates a :class:`pandas.Timestamp`.
 15 | 
 16 | async_v20 adds an additional helper method *Timestamp*. **json()** for the purpose
 17 | of serializing to the correct JSON format OANDA expects.
 18 | 
 19 | .. note::
 20 |     This method is not part of the public API, it is documented here to give you an understanding
 21 |     of how async_v20 parses datetime like arguments into JSON that meets OANDA's specification
 22 | 
 23 | **Example**
 24 | 
 25 | .. code-block:: python
 26 | 
 27 |     >>> from async_v20 import OandaClient
 28 |     >>> import asyncio
 29 |     >>> from time import time
 30 |     >>> from datetime import datetime
 31 |     >>> loop = asyncio.get_event_loop()
 32 |     >>> run = loop.run_until_complete
 33 |     >>> client = OandaClient()
 34 |     >>> rsp = run(client.get_candles(
 35 |     ...     'AUD_JPY',
 36 |     ...     granularity='M1', # 1 minute candles
 37 |     ...     from_time=time() - (10 * 60),  # 10 minutes ago
 38 |     ...     to_time=datetime.utcnow()  # Current time
 39 |     ... ))
 40 |     >>> rsp
 41 |     <Status [200]: instrument, granularity, candles>
 42 |     >>> len(rsp.candles)  # I was aiming for 10
 43 |     11
 44 | 
 45 | **Serializing**
 46 | 
 47 | .. code-block:: python
 48 | 
 49 |     >>> from async_v20 import DateTime
 50 |     >>> unix_example = '1502463871.639182000'
 51 |     >>> rfc3339_example = '2017-08-11T15:04:31.639182000Z'
 52 |     >>> dt = DateTime(unix_example)
 53 |     >>> dt
 54 |     Timestamp('2017-08-11 15:04:31.639182+0000', tz='UTC')
 55 |     >>> dt.json('RFC3339')
 56 |     '2017-08-11T15:04:31.639182000Z'
 57 |     >>> dt.json('UNIX')
 58 |     '1502463871.639182000'
 59 |     >>> dt.json('UNIX') == unix_example
 60 |     True
 61 |     >>> dt = DateTime(rfc3339_example)
 62 |     >>> dt.json('UNIX')
 63 |     '1502463871.639182000'
 64 |     >>> dt.json('UNIX') == unix_example
 65 |     True
 66 | 
 67 | **Creating from time.time()**
 68 | 
 69 | .. code-block:: python
 70 | 
 71 |     >>> from async_v20 import DateTime
 72 |     >>> from time import time
 73 |     >>> dt = DateTime(time())
 74 |     >>> dt
 75 |     Timestamp('2017-12-21 01:22:37.762530+0000', tz='UTC')
 76 |     >>> dt.json('UNIX')
 77 |     '1513819357.762530000'
 78 |     >>> dt.json('RFC3339')
 79 |     '2017-12-21T01:22:37.762530000Z'
 80 | 
 81 | **Creating from datetime.datetime.now()**
 82 | 
 83 | .. code-block:: python
 84 | 
 85 |     >>> from async_v20 import DateTime
 86 |     >>> from datetime import datetime
 87 |     >>> dt = DateTime(datetime.now())
 88 |     >>> dt
 89 |     Timestamp('2017-12-21 12:31:03.982327')
 90 | 
 91 | 
 92 | **DataFrame**
 93 | 
 94 | .. code-block:: python
 95 | 
 96 |     >>> from async_v20 import OandaClient
 97 |     >>> import asyncio
 98 |     >>> loop = asyncio.get_event_loop()
 99 |     >>> run = loop.run_until_complete
100 |     >>> client = OandaClient()
101 |     >>> rsp = run(client.get_candles('EUR_USD'))
102 |     >>> df = rsp.candles.dataframe()
103 |     >>> df.time[0]
104 |     ... Timestamp('2017-12-20 23:30:40+0000', tz='UTC')
105 |     >>> df = rsp.candles.dataframe(datetime_format='RFC3339')
106 |     >>> df.time[0]
107 |     '2017-12-20T23:30:40.000000000Z'
108 |     >>> df = rsp.candles.dataframe(datetime_format='UNIX')
109 |     >>> df.time[0]
110 |     1513812640000000000
111 |     >>> type(df.time[0])
112 |     # <class 'numpy.int64'>
113 |     >>> df = rsp.candles.dataframe(json=True, datetime_format='UNIX')
114 |     >>> df.time[0]
115 |     '1513812640.000000000'
116 |     >>> type(df.time[0])
117 |     # <class 'str'>
118 | 


--------------------------------------------------------------------------------
/doc/source/definitions/account.rst:
--------------------------------------------------------------------------------
 1 | .. _account-types:
 2 | 
 3 | Account
 4 | =======
 5 | 
 6 | .. autoclass:: async_v20.AccountProperties
 7 | .. autoclass:: async_v20.AccountChangesState
 8 | .. autoclass:: async_v20.AccountSummary
 9 | .. autoclass:: async_v20.Account
10 | .. autoclass:: async_v20.AccountChanges


--------------------------------------------------------------------------------
/doc/source/definitions/instrument.rst:
--------------------------------------------------------------------------------
 1 | .. _instrument-types:
 2 | 
 3 | Instrument
 4 | ==========
 5 | 
 6 | .. autoclass:: async_v20.Candlestick
 7 | .. autoclass:: async_v20.CandlestickData
 8 | .. autoclass:: async_v20.OrderBook
 9 | .. autoclass:: async_v20.OrderBookBucket
10 | .. autoclass:: async_v20.PositionBook
11 | .. autoclass:: async_v20.PositionBookBucket


--------------------------------------------------------------------------------
/doc/source/definitions/order.rst:
--------------------------------------------------------------------------------
 1 | .. _order-types:
 2 | 
 3 | Order
 4 | =====
 5 | 
 6 | .. autoclass:: async_v20.Order
 7 | .. autoclass:: async_v20.MarketOrder
 8 | .. autoclass:: async_v20.LimitOrder
 9 | .. autoclass:: async_v20.StopOrder
10 | .. autoclass:: async_v20.MarketIfTouchedOrder
11 | .. autoclass:: async_v20.TakeProfitOrder
12 | .. autoclass:: async_v20.StopLossOrder
13 | .. autoclass:: async_v20.TrailingStopLossOrder
14 | .. autoclass:: async_v20.OrderRequest
15 | .. autoclass:: async_v20.MarketOrderRequest
16 | .. autoclass:: async_v20.LimitOrderRequest
17 | .. autoclass:: async_v20.StopOrderRequest
18 | .. autoclass:: async_v20.MarketIfTouchedOrderRequest
19 | .. autoclass:: async_v20.TakeProfitOrderRequest
20 | .. autoclass:: async_v20.StopLossOrderRequest
21 | .. autoclass:: async_v20.TrailingStopLossOrderRequest
22 | .. autoclass:: async_v20.DynamicOrderState
23 | .. autoclass:: async_v20.UnitsAvailableDetails
24 | .. autoclass:: async_v20.UnitsAvailable
25 | 


--------------------------------------------------------------------------------
/doc/source/definitions/positions.rst:
--------------------------------------------------------------------------------
 1 | .. _position-types:
 2 | 
 3 | Positions
 4 | =========
 5 | 
 6 | .. autoclass:: async_v20.Position
 7 | .. autoclass:: async_v20.PositionSide
 8 | .. autoclass:: async_v20.CalculatedPositionState
 9 | 
10 | 


--------------------------------------------------------------------------------
/doc/source/definitions/pricing.rst:
--------------------------------------------------------------------------------
 1 | .. _pricing-types:
 2 | 
 3 | Pricing
 4 | =======
 5 | 
 6 | .. autoclass:: async_v20.Price
 7 | .. autoclass:: async_v20.PriceBucket
 8 | .. autoclass:: async_v20.QuoteHomeConversionFactors
 9 | .. autoclass:: async_v20.ClientPrice
10 | .. autoclass:: async_v20.PricingHeartbeat
11 | 


--------------------------------------------------------------------------------
/doc/source/definitions/trade.rst:
--------------------------------------------------------------------------------
1 | .. _trade-types:
2 | 
3 | Trade
4 | =====
5 | 
6 | .. autoclass:: async_v20.Trade
7 | .. autoclass:: async_v20.TradeSummary
8 | .. autoclass:: async_v20.CalculatedTradeState


--------------------------------------------------------------------------------
/doc/source/definitions/transaction.rst:
--------------------------------------------------------------------------------
 1 | .. _transaction-types:
 2 | 
 3 | Transaction
 4 | ===========
 5 | 
 6 | .. autoclass:: async_v20.Transaction
 7 | .. autoclass:: async_v20.CreateTransaction
 8 | .. autoclass:: async_v20.CloseTransaction
 9 | .. autoclass:: async_v20.ReopenTransaction
10 | .. autoclass:: async_v20.ClientConfigureTransaction
11 | .. autoclass:: async_v20.ClientConfigureRejectTransaction
12 | .. autoclass:: async_v20.TransferFundsTransaction
13 | .. autoclass:: async_v20.TransferFundsRejectTransaction
14 | .. autoclass:: async_v20.MarketOrderTransaction
15 | .. autoclass:: async_v20.MarketOrderRejectTransaction
16 | .. autoclass:: async_v20.LimitOrderTransaction
17 | .. autoclass:: async_v20.LimitOrderRejectTransaction
18 | .. autoclass:: async_v20.StopOrderTransaction
19 | .. autoclass:: async_v20.StopOrderRejectTransaction
20 | .. autoclass:: async_v20.MarketIfTouchedOrderTransaction
21 | .. autoclass:: async_v20.MarketIfTouchedOrderRejectTransaction
22 | .. autoclass:: async_v20.TakeProfitOrderTransaction
23 | .. autoclass:: async_v20.TakeProfitOrderRejectTransaction
24 | .. autoclass:: async_v20.StopLossOrderTransaction
25 | .. autoclass:: async_v20.StopLossOrderRejectTransaction
26 | .. autoclass:: async_v20.TrailingStopLossOrderTransaction
27 | .. autoclass:: async_v20.TrailingStopLossOrderRejectTransaction
28 | .. autoclass:: async_v20.OrderFillTransaction
29 | .. autoclass:: async_v20.OrderCancelTransaction
30 | .. autoclass:: async_v20.OrderCancelRejectTransaction
31 | .. autoclass:: async_v20.OrderClientExtensionsModifyTransaction
32 | .. autoclass:: async_v20.OrderClientExtensionsModifyRejectTransaction
33 | .. autoclass:: async_v20.TradeClientExtensionsModifyTransaction
34 | .. autoclass:: async_v20.TradeClientExtensionsModifyRejectTransaction
35 | .. autoclass:: async_v20.MarginCallEnterTransaction
36 | .. autoclass:: async_v20.MarginCallExtendTransaction
37 | .. autoclass:: async_v20.MarginCallExitTransaction
38 | .. autoclass:: async_v20.DelayedTradeClosureTransaction
39 | .. autoclass:: async_v20.DailyFinancingTransaction
40 | .. autoclass:: async_v20.ResetResettablePLTransaction
41 | .. autoclass:: async_v20.ClientExtensions
42 | .. autoclass:: async_v20.TakeProfitDetails
43 | .. autoclass:: async_v20.StopLossDetails
44 | .. autoclass:: async_v20.TrailingStopLossDetails
45 | .. autoclass:: async_v20.TradeOpen
46 | .. autoclass:: async_v20.TradeReduce
47 | .. autoclass:: async_v20.MarketOrderTradeClose
48 | .. autoclass:: async_v20.MarketOrderMarginCloseout
49 | .. autoclass:: async_v20.MarketOrderDelayedTradeClose
50 | .. autoclass:: async_v20.MarketOrderPositionCloseout
51 | .. autoclass:: async_v20.VWAPReceipt
52 | .. autoclass:: async_v20.LiquidityRegenerationSchedule
53 | .. autoclass:: async_v20.LiquidityRegenerationScheduleStep
54 | .. autoclass:: async_v20.OpenTradeFinancing
55 | .. autoclass:: async_v20.PositionFinancing
56 | .. autoclass:: async_v20.TransactionHeartbeat
57 | 
58 | 


--------------------------------------------------------------------------------
/doc/source/environment_variables.rst:
--------------------------------------------------------------------------------
 1 | .. _adding-environment-variables:
 2 | 
 3 | Adding Environment Variables
 4 | ============================
 5 | 
 6 | Due to the abundance of information in regards to configuring environment
 7 | variables, it can be challenging to find information that will result in success.
 8 | 
 9 | Here we will try and and point you in the correct direction.
10 | 
11 | PyCharm
12 | -------
13 | 
14 |     https://stackoverflow.com/questions/42708389/how-to-set-environment-variables-in-pycharm
15 | 
16 | Mac
17 | ---
18 |     https://stackoverflow.com/questions/135688/setting-environment-variables-in-os-x/3756686#3756686
19 | 
20 | Windows
21 | -------
22 | 
23 |     https://stackoverflow.com/questions/1672281/environment-variables-for-java-installation
24 | 
25 | Ubuntu
26 | ------
27 | 
28 |     https://askubuntu.com/questions/58814/how-do-i-add-environment-variables
29 | 
30 | 
31 | What is an environment variable?
32 | --------------------------------
33 | 
34 | For our requirements, we will think of an environment variable,
35 | as a variable stored outside the scope of the application.
36 | 
37 | Python programs can access these variables via the *os* module
38 | 
39 | Why store the token in an environment variable?
40 | _______________________________________________
41 | 
42 | There are a couple of reason. Primarily:
43 | 
44 |  - Convenience, create a client with `OandaClient()` not
45 |    `OandaClient(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx)`
46 |  - Secure, prevents you from uploading the token to an online repository
47 |  - May simplify deployment of your trading program
48 | 
49 | 


--------------------------------------------------------------------------------
/doc/source/exceptions.rst:
--------------------------------------------------------------------------------
 1 | Exceptions
 2 | ==========
 3 | 
 4 | .. autoclass:: async_v20.exceptions.AsyncV20Exception
 5 | .. autoclass:: async_v20.exceptions.CloseAllTradesFailure
 6 | .. autoclass:: async_v20.exceptions.FailedToCreatePath
 7 | .. autoclass:: async_v20.exceptions.IncompatibleValue
 8 | .. autoclass:: async_v20.exceptions.InitializationFailure
 9 | .. autoclass:: async_v20.exceptions.InstantiationFailure
10 | .. autoclass:: async_v20.exceptions.InvalidFormatArguments
11 | .. autoclass:: async_v20.exceptions.InvalidOrderRequest
12 | .. autoclass:: async_v20.exceptions.InvalidValue
13 | .. autoclass:: async_v20.exceptions.ResponseTimeout
14 | .. autoclass:: async_v20.exceptions.UnexpectedStatus
15 | 
16 | 
17 | Warnings
18 | ========
19 | 
20 | .. autoclass:: async_v20.exceptions.UnknownKeywordArgument


--------------------------------------------------------------------------------
/doc/source/getting_started.rst:
--------------------------------------------------------------------------------
 1 | Getting started
 2 | ===============
 3 | 
 4 | 
 5 | .. _create-account:
 6 | 
 7 | Creating an Account
 8 | -------------------
 9 | 
10 | To use :term:`async_v20` you must have an account with :term:`OANDA`
11 | 
12 |     - Create an account `HERE <https://www.oanda.com/account/login>`_
13 |     - Create an API :term:`token` `ALSO HERE <https://www.oanda.com/demo-account/tpa/personal_token>`_
14 | 
15 | .. _setting-up-environment:
16 | 
17 | Setting up environment
18 | ----------------------
19 | 
20 |     - Install :term:`async_v20` as per :ref:`installation`
21 |     - Create a new :term:`environment variable` with the name `OANDA_TOKEN` and value as
22 |       the :term:`token` generated from :ref:`create-account`.
23 | 
24 |     .. toctree::
25 |         environment_variables
26 | 
27 | 
28 |     .. note::
29 | 
30 |         - It is considered best practice use a :term:`virtual environment`
31 |         - It is not required to store the token in an :term:`environment variable`. The token can be passed to :ref:`OandaClient`
32 | 
33 | .. _tutorial:
34 | 
35 | Using async_v20
36 | ---------------
37 | 
38 | Once an account has been created as per :ref:`create-account`
39 | and the environment is configured as per :ref:`setting-up-environment`,
40 | we are ready to begin.
41 | 
42 | Lets first take a look at this code example, then go though it line by line.
43 | 
44 | .. literalinclude:: ../../bin/account.py
45 |     :lines: 1-16
46 | 
47 | 
48 | First we need to import :term:`asyncio` this allows us to run our :term:`coroutine`
49 | 
50 | .. literalinclude:: ../../bin/account.py
51 |     :lines: 1
52 | 
53 | We then import `OandaClient` which provides us the means to interact with OANDA
54 | 
55 | .. literalinclude:: ../../bin/account.py
56 |     :lines: 3
57 | 
58 | Because `OandaClient` returns `coroutines` we use `async def`. This allows the use of the `await` syntax
59 | 
60 | .. literalinclude:: ../../bin/account.py
61 |     :lines: 6
62 | 
63 | `OandaClient` is a :term:`context manager`, we use `async with` to instantiate a
64 | client instance. Doing so will automatically close the `http session` when we're done
65 | 
66 | .. literalinclude:: ../../bin/account.py
67 |     :lines: 7
68 | 
69 | We then create and :term:`await` the :term:`coroutine` by calling `client`. **account()**
70 | 
71 | .. literalinclude:: ../../bin/account.py
72 |     :lines: 8
73 | 
74 | Now we have defined our :term:`coroutine` we need to execute it.
75 | To do so we need an event loop. Achieved using `asyncio`. **get_event_loop()**
76 | 
77 | .. literalinclude:: ../../bin/account.py
78 |     :lines: 11
79 | 
80 | The value returned by executing the `account` :term:`coroutine` is accessed through the event loop.
81 | 
82 | .. literalinclude:: ../../bin/account.py
83 |     :lines: 12
84 | 
85 | :term:`async_v20` objects have a `Model`. **series()** method that returns a :term:`pandas`. **Series**
86 | 
87 | .. literalinclude:: ../../bin/account.py
88 |     :lines: 15
89 | 
90 | .. note::
91 | 
92 |     Each application should only instantiate **ONE** OandaClient instance per account.
93 |     See :ref:`best-practices`.
94 | 


--------------------------------------------------------------------------------
/doc/source/glossary.rst:
--------------------------------------------------------------------------------
  1 | .. _glossary:
  2 | 
  3 | 
  4 | ==========
  5 |  Glossary
  6 | ==========
  7 | 
  8 | .. if you add new entries, keep the alphabetical sorting!
  9 | 
 10 | .. glossary::
 11 |    :sorted:
 12 | 
 13 |    aiohttp
 14 | 
 15 |       http client/server framework :term:`async_v20` use's to communicate asynchronously.
 16 | 
 17 |       http://aiohttp.readthedocs.io/en/stable/
 18 | 
 19 |    aiodns
 20 | 
 21 |       An python package for asynchronous DNS resolution.
 22 | 
 23 |       https://github.com/saghul/aiodns
 24 | 
 25 |    asyncio
 26 | 
 27 |       The library for writing single-threaded concurrent code using
 28 |       coroutines, multiplexing I/O access over sockets and other
 29 |       resources, running network clients and servers, and other
 30 |       related primitives.
 31 | 
 32 |       Reference implementation of :pep:`3156`
 33 | 
 34 |       https://pypi.python.org/pypi/asyncio/
 35 | 
 36 |    async_v20
 37 | 
 38 |       The name of the package this documentation is documenting
 39 | 
 40 |       https://github.com/jamespeterschinner/async_v20
 41 | 
 42 |    annotation
 43 | 
 44 |       Used to describe what :term:`type` an argument takes
 45 | 
 46 |       https://www.python.org/dev/peps/pep-0526/
 47 | 
 48 |    attribute
 49 | 
 50 |       An attribute is the term used to describe variables associated with a :term:`class`
 51 |       that contains information about that class' state.
 52 | 
 53 |    attributes
 54 | 
 55 |       plural of :term:`attribute`
 56 | 
 57 |    arguments
 58 | 
 59 |       are values passed to a function
 60 | 
 61 |    await
 62 | 
 63 |       Python syntax to execute a :term:`coroutine` inside an asynchronous function
 64 | 
 65 |    callable
 66 | 
 67 |       Any object that can be called. Use :func:`callable` to check
 68 |       that.
 69 | 
 70 |    camelCase
 71 | 
 72 |       A style of text that uses capital letters to separate words
 73 | 
 74 |    cchardet
 75 | 
 76 | 
 77 |        cChardet is high speed universal character encoding detector -
 78 |        binding to charsetdetect.
 79 | 
 80 |        https://pypi.python.org/pypi/cchardet/
 81 | 
 82 |    class
 83 | 
 84 |       Classes provide a means of bundling data and functionality together.
 85 |       Creating a new class creates a new type of object, allowing new instances of that type to be made.
 86 |       Each class instance can have attributes attached to it for maintaining its state.
 87 |       Class instances can also have methods (defined by its class) for modifying its state.
 88 | 
 89 |       https://docs.python.org/3/tutorial/classes.html
 90 | 
 91 |    concurrent
 92 | 
 93 |       The process by which a single threaded application switches between
 94 |       different tasks. Typically done to prevent waiting for I/O bound operations
 95 | 
 96 |    coroutine
 97 | 
 98 |       A python object that supports asynchronous execution
 99 | 
100 |    coroutines
101 | 
102 |       plural of :term:`coroutine`
103 | 
104 |    context manager
105 | 
106 |       A Python programming concept that defines `enter` and `exit` methods. Used to handle set-up
107 |       and tear-down tasks
108 | 
109 |    docstring
110 | 
111 |       text placed below a function or class definition that documents the function or class
112 | 
113 |       https://www.python.org/dev/peps/pep-0257/
114 | 
115 |    environment variable
116 | 
117 |       An environment variable is a dynamic-named value that can affect the way running processes
118 |       will behave on a computer. They are part of the environment in which a process runs
119 | 
120 | 
121 |    http
122 | 
123 |       Stands for Hyper Text Transfer Protocol
124 | 
125 |       https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol
126 | 
127 |    JSON
128 | 
129 |       JavaScript Object Notation
130 | 
131 |       http://www.json.org/
132 | 
133 |    key
134 | 
135 |        The value used to index a dictionary
136 | 
137 |    metaclass
138 | 
139 |       A python :term:`class` definition that inherits from `type`.
140 |       It allows programmers to customize class creation as if they typed the entire class
141 | 
142 |       https://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
143 | 
144 |    OANDA
145 | 
146 |       The name of the Foreign Exchange (FOREX) broker :term:`async_v20` communicates with
147 | 
148 |    OandaClient
149 | 
150 |       The client class definition :term:`async_v20` exposes
151 | 
152 |    pandas
153 | 
154 |       a Python package providing fast, flexible, and expressive data structures
155 |       designed to make working with "relational" or "labeled" data both easy and intuitive
156 | 
157 |       http://pandas.pydata.org/
158 | 
159 |    python
160 | 
161 |       Programming language
162 | 
163 |       https://www.python.org/
164 | 
165 |    snake_case
166 | 
167 |       a style of text that uses underscores to separate words
168 | 
169 |    status
170 | 
171 |       When prefixed with http. Refers to a 3 digit number with pre-assigned meaning.
172 | 
173 |       https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Status_codes
174 | 
175 |    token
176 | 
177 |       A 65 character string used to uniquely identify and authorise access to the OANDA v20 API
178 | 
179 |       Example:
180 |          `810492ace47473fa9f72c0eeecd33657-1eae8a55f01431bdd370206f69071e5f`
181 | 
182 |    type
183 | 
184 |       In computer science and computer programming,
185 |       a data type or simply type is a classification of data which tells the compiler or
186 |       interpreter how the programmer intends to use the data.
187 | 
188 |       https://en.wikipedia.org/wiki/Data_type
189 | 
190 |    virtual environment
191 | 
192 |       A self-contained directory tree that contains a Python installation for a particular version of Python,
193 |       plus a number of additional packages.
194 | 
195 |       https://docs.python.org/3/tutorial/venv.html


--------------------------------------------------------------------------------
/doc/source/health.rst:
--------------------------------------------------------------------------------
 1 | .. _health_api:
 2 | 
 3 | Health API
 4 | ==========
 5 | 
 6 | async_v20 includes OANDA's v20 health `API <http://developer.oanda.com/rest-live-v20/health/>`_.
 7 | 
 8 | During the initialization of OandaClient the statuses of the services are checked.
 9 | A warning is logged for each service that is not currently up.
10 | 
11 | Users are encouraged to explicitly check the service they wish to use is available.
12 | 
13 | see :ref:`health` for complete list of API calls.
14 | 
15 | Example:
16 | 
17 | .. code-block:: python
18 | 
19 |     >>> from async_v20 import OandaClient
20 |     >>> import asyncio
21 |     >>> client = OandaClient()
22 |     >>> loop = asyncio.get_event_loop()
23 |     >>> run = loop.run_until_complete
24 |     >>> rsp = run(client.list_services())
25 |     >>> rsp
26 |     # <Status [200]: services>
27 |     >>> rsp.services
28 |     # (<Service: id=fxtrade-practice-rest-api>,
29 |     # <Service: id=fxtrade-practice-streaming-api>,
30 |     # <Service: id=fxtrade-rest-api>,
31 |     # <Service: id=fxtrade-streaming-api>)
32 |     >>> rsp.services.get_id('fxtrade-practice-streaming-api')
33 |     # <Service: id=fxtrade-practice-streaming-api>
34 |     >>> rsp.services.get_id('fxtrade-practice-streaming-api').current_event.status.description
35 |     # 'The service is up'
36 | 
37 | 


--------------------------------------------------------------------------------
/doc/source/index.rst:
--------------------------------------------------------------------------------
  1 | .. _async_v20-home:
  2 | 
  3 | 
  4 | async_v20: Asynchronous OANDA v20 client
  5 | ========================================
  6 |     *A foreign exchange client*
  7 | 
  8 | .. image:: https://raw.githubusercontent.com/jamespeterschinner/async_v20/master/doc/source/_static/async_v20-icon-128x128.png
  9 |     :alt: async-v20 logo
 10 | 
 11 | .. image:: https://travis-ci.org/jamespeterschinner/async_v20.svg?branch=master
 12 |   :target: https://travis-ci.org/jamespeterschinner/async_v20
 13 | 
 14 | 
 15 | .. image:: https://codecov.io/gh/jamespeterschinner/async_v20/branch/master/graph/badge.svg
 16 |   :target: https://codecov.io/gh/jamespeterschinner/async_v20
 17 | 
 18 | 
 19 | .. image:: https://readthedocs.org/projects/async-v20/badge/?version=latest
 20 |   :target: http://async-v20.readthedocs.io/en/latest/?badge=latest
 21 |   :alt: Documentation Status
 22 | 
 23 | Disclaimer
 24 | ----------
 25 | 
 26 | - **Losses can exceed investment.**
 27 | - async_v20 and its creator has no affiliation with OANDA. And is not endorsed by OANDA in any manner.
 28 | - async_v20 is in Beta stage and has not been tested on a live OANDA account
 29 | - **Use at own risk**
 30 | 
 31 | Features
 32 | ---------
 33 | 
 34 | - Exposes the entire `v20 API <http://developer.oanda.com/rest-live-v20/introduction/>`_ `
 35 | - immutable objects
 36 | - No `*args, **kwargs` In client methods. So no guessing what arguments a method takes
 37 | - Serialize objects directly into *pandas* **Series** or **DataFrame** objects
 38 | - Construct :term:`concurrent` trading algorithms
 39 | 
 40 | .. _installation:
 41 | 
 42 | installation
 43 | ------------
 44 | 
 45 | .. code-block:: bash
 46 | 
 47 |    $ pip install async_v20
 48 | 
 49 | :term:`async_v20` is built with `aiohttp <https://github.com/aio-libs/aiohttp>`_.
 50 | It is therefore recommended to also install :term:`cchardet` and :term:`aiodns` as per :term:`aiohttp`
 51 | `documentation <http://aiohttp.readthedocs.io/en/stable/>`_ `
 52 | 
 53 | .. code-block:: bash
 54 | 
 55 |    $ pip install cchardet
 56 | 
 57 |    $ pip install aiodns
 58 | 
 59 | Why async_v20?
 60 | --------------
 61 | 
 62 | There are many OANDA clients for python already available so why create another?
 63 | The main driver for creating async_v20 was to facilitate better risk management,
 64 | by allowing user's to concurrently monitor account status and trade currency's.
 65 | 
 66 | An unintended consequence of async_v20 is the ability to create clear segregation
 67 | between implementation ideas.
 68 | 
 69 | A simple example might contain a coroutine for the following:
 70 | 
 71 |     - Monitoring overall account status
 72 |     - Watching price stream and triggering buy/sell signals
 73 |     - Monitoring individual trades and closing movements against held positions
 74 | 
 75 | A synchronous implementation would require considerable effort to determine which
 76 | task communicates with the server next. async_v20 removes this burden by using
 77 | `aiohttp <https://github.com/aio-libs/aiohttp>`_
 78 | 
 79 | Further goals of async_v20 has been to lower the barrier of entry for algorithmic trading
 80 | by providing a complete and simple to use interface.
 81 | 
 82 | Tutorial
 83 | --------
 84 | 
 85 | :ref:`tutorial`
 86 | 
 87 | Source code
 88 | -----------
 89 | 
 90 | Can be found on `GitHub <https://github.com/jamespeterschinner/async_v20>`_
 91 | 
 92 | Please feel free to file an issue on the bug tracker if you have found a bug
 93 | or have some suggestion in order to improve the client.
 94 | 
 95 | 
 96 | Dependencies
 97 | ------------
 98 | 
 99 | - **python >= 3.6**
100 | - aiohttp >= 2.2.5
101 | - ujson >= 1.35'
102 | - yarl >= 0.12.0'
103 | - pandas
104 | 
105 | Contents
106 | --------
107 | .. toctree::
108 | 
109 |    getting_started
110 |    best_practices
111 |    beyond_getting_started
112 |    order_request_formatting
113 |    datetimes
114 |    health
115 |    traps
116 |    api
117 |    response
118 |    particularly_pertinent
119 |    types
120 |    primitives
121 |    annotations
122 |    exceptions
123 |    logging
124 |    glossary
125 | 
126 | 


--------------------------------------------------------------------------------
/doc/source/logging.rst:
--------------------------------------------------------------------------------
 1 | Logging
 2 | =======
 3 | 
 4 | async_v20 employs the `logging.getLogger(__name__)` standard for all it's modules.
 5 | Hence the base logger for async_v20 is 'async_v20'
 6 | 
 7 | :class:`~async_v20.OandaClient` has a `debug` attribute for enabling the logging of debug level messages.
 8 | 
 9 | **Example**
10 | 
11 | .. code-block:: python
12 | 
13 |     >>> from async_v20 import OandaClient
14 |     >>> import asyncio
15 |     >>> import logging
16 |     >>> loop = asyncio.get_event_loop()
17 |     >>> run = loop.run_until_complete
18 |     >>> import logging
19 |     >>> logger = logging.getLogger('async_v20')
20 |     >>> handler = logging.StreamHandler()
21 |     >>> logger.addHandler(handler)
22 |     >>> logger.setLevel(logging.INFO)
23 |     >>> client = OandaClient()
24 |     >>> rsp = run(client.close_all_trades())
25 |     # close_all_trades()
26 |     # Initializing client
27 |     # Initializing session
28 |     # list_services(args=(), kwargs={})
29 |     # list_accounts(args=(), kwargs={})
30 |     # get_account_details(args=(), kwargs={})
31 |     # account_instruments(args=(), kwargs={})
32 |     # list_open_trades(args=(), kwargs={})
33 |     # list_open_trades(args=(), kwargs={})


--------------------------------------------------------------------------------
/doc/source/order_request_formatting.rst:
--------------------------------------------------------------------------------
 1 | Formatting Order Requests
 2 | =========================
 3 | 
 4 | :class:`~async_v20.OandaClient` provides the option to format :class:`~async_v20.definitions.types.OrderRequest`'s
 5 | in the context of the instrument the OrderRequest is for.
 6 | 
 7 | Confused? So was I, Let's have a look at an `instrument`. **series()**
 8 | representation of an :class:`~async_v20.definitions.types.Instrument`.
 9 | 
10 | .. code-block:: python
11 |     :emphasize-lines: 2,4-8,11
12 | 
13 |     display_name                      Brent Crude Oil
14 |     display_precision                               3
15 |     margin_rate                                  0.05
16 |     maximum_order_units                        100000
17 |     maximum_position_size                           0
18 |     maximum_trailing_stop_distance                100
19 |     minimum_trade_size                              1
20 |     minimum_trailing_stop_distance               0.05
21 |     name                                      BCO_USD
22 |     pip_location                                   -2
23 |     trade_units_precision                           0
24 |     type                                          CFD
25 |     dtype: object
26 | 
27 | The above instrument outlines the formatting of an *OrderRequest* for the *Instrument* (in this case *Brent Crude Oil*).
28 | Take *Instrument*. **trade_units_precision** as an example, this attribute defines how many decimal places
29 | :class:`~async_v20.definition.types.OrderRequest`. **units** may be used for this instrument (our example *0*).
30 | 
31 | You will also notice **minimum** and **maximum** values for other *OrderRequest* attributes.
32 | 
33 | *OandaClient*. **format_order_requests** is a boolean value which changes the degree to which
34 | *OrderRequest*'s will be modified to comply with the instrument specification.
35 | If **format_order_requests** is set to
36 | :class:`True` *OandaClient* will modify values so that they are within
37 | the valid range specified by the instrument.
38 | 
39 | .. note::
40 |     I believe most users will want to use this feature as it dramatically
41 |     reduces the complexity of placing valid OrderRequests. It is disabled by default.
42 | 
43 |     Only enable this feature if you understand that your `OrderRequest`. **stop_loss_on_fill**/
44 |     **take_profit_on_fill**/**trailing_stop_loss_distance** and **price_bound** configuration may
45 |     be altered to comply with the instruments valid ranges.
46 | 
47 | .. note::
48 |     The precision of :class:`~async_v20.definitions.primitives.DecimalNumber` and
49 |     :class:`~async_v20.definitions.primitive.PriceValue` will **always** be rounded
50 |     to the correct precision for the instrument, regardless of *OandaClient*. **format_order_requests**
51 |     value.
52 | 
53 | 
54 | **Example:**
55 | 
56 | .. code-block:: python
57 |     :emphasize-lines: 10-12,15,19
58 | 
59 |     >>> from async_v20 import OandaClient
60 |     >>> import asyncio
61 |     >>> client = OandaClient()
62 |     >>> run = loop.run_until_complete
63 |     >>> run(client.create_order('AUD_USD', 0))
64 |     Traceback (most recent call last):
65 |     ValueError: OrderRequest units 0.0 are less than the minimum trade size 1.0
66 |     >>> run(client.create_order('AUD_USD', 1))
67 |     <Status [201]: orderCreateTransaction, orderFillTransaction, relatedTransactionIDs, lastTransactionID>
68 |     >>> client.format_order_requests
69 |     False
70 |     >>> client.format_order_requests = True
71 |     >>> run(client.create_order('AUD_USD', 0))
72 |     <Status [201]: orderCreateTransaction, orderFillTransaction, relatedTransactionIDs, lastTransactionID>
73 |     >>> client.format_order_requests = False
74 |     >>> run(client.create_order('AUD_USD', 1, trailing_stop_loss_on_fill=0))
75 |     Traceback (most recent call last):
76 |     ValueError: Trailing stop loss distance 0.0 is not within AUD_USD specified range 0.0005 - 1.0
77 |     >>> client.format_order_requests = True
78 |     >>> run(client.create_order('AUD_USD', 1, trailing_stop_loss_on_fill=0))
79 |     <Status [201]: orderCreateTransaction, orderFillTransaction, relatedTransactionIDs, lastTransactionID>


--------------------------------------------------------------------------------
/doc/source/particularly_pertinent.rst:
--------------------------------------------------------------------------------
 1 | .. _particularly_pertinent:
 2 | 
 3 | Particularly Pertinent Programming Interface
 4 | ============================================
 5 | 
 6 | There are two additional helper methods that :ref:`OandaClient` exposes, beyond OANDA's
 7 | own `v20 <https://github.com/oanda/v20-python/tree/master/src>`_ client;
 8 | :meth:`~async_v20.OandaClient.account`, :meth:`~async_v20.OandaClient.close_all_trades`.
 9 | 
10 | Getting the Account Status
11 | --------------------------
12 | 
13 | OANDA's v20 API is a RESTful service. Meaning that the server only sends the changes to the account,
14 | rather then the full account. This is useful, in that it reduces network traffic,
15 | but requires addition computation on the client side. As changes sent from the server must be
16 | incorporated locally.
17 | 
18 | This functionality is implemented in the :meth:`~async_v20.OandaClient.account` method.
19 | 
20 | In order to check the status of the account. Use the await syntax, like so:
21 | 
22 | .. literalinclude:: ../../bin/account.py
23 |     :lines: 5-8
24 | 
25 | .. note::
26 | 
27 |     The :meth:`~async_v20.OandaClient.account` method uses the response from
28 |     :meth:`~async_v20.OandaClient.account_changes` to update the local account object.
29 |     the response from :meth:`~async_v20.OandaClient.account_changes` contains more information
30 |     than the :class:`~async_v20.definitions.types.Account` specifies. Meaning that some
31 |     information contained in the :meth:`~async_v20.OandaClient.account_changes` response
32 |     is lost when updating the account. It has been chosen to only keep
33 |     :class:`~async_v20.definitions.types.Order`'s
34 |     :class:`~async_v20.definitions.types.Trade`'s
35 |     :class:`~async_v20.definitions.types.Position`'s,
36 |     in the account that are currently open.
37 |     This is to resemble the behaviour of OANDA's Web based browser interface
38 | 
39 |     :class:`~async_v20.definitions.types.Transaction`'s are stored on the
40 |     client as :attr:`~async_v20.OandaClient.transactions`
41 | 
42 | Closing all Trades
43 | ------------------
44 | 
45 | The :meth:`~async_v20.OandaClient.close_all_trades` method is provided to help facilitate
46 | your risk management policy. async_v20 is intended to be used as an algorithmic trading platform,
47 | which naturally raises concerns of run away losses, to the unbeknown user.
48 | 
49 | :meth:`~async_v20.OandaClient.close_all_trades` is intended to help mitigate this concern by allowing
50 | users to programme a `global` :term:`stop loss` by which all trades can be terminated.
51 | 
52 | .. note::
53 |     Users who implement this feature should account for the **Two** possible outcomes.
54 | 
55 |     - A :class:`~async_v20.exceptions.CloseAllTradesFailure` is raised
56 | 
57 |     **OR**
58 | 
59 |     - returns (**True**, `closed_trade_responses`) - All trades were closed
60 | 
61 | 
62 | 


--------------------------------------------------------------------------------
/doc/source/primitives.rst:
--------------------------------------------------------------------------------
 1 | Primitives
 2 | ==========
 3 | 
 4 | .. autoclass:: async_v20.AcceptDatetimeFormat
 5 | .. autoclass:: async_v20.AccountFinancingMode
 6 | .. autoclass:: async_v20.AccountID
 7 | .. autoclass:: async_v20.AccountUnits
 8 | .. autoclass:: async_v20.CancellableOrderType
 9 | .. autoclass:: async_v20.CandlestickGranularity
10 | .. autoclass:: async_v20.ClientComment
11 | .. autoclass:: async_v20.ClientID
12 | .. autoclass:: async_v20.ClientTag
13 | .. autoclass:: async_v20.Currency
14 | .. autoclass:: async_v20.DateTime
15 | .. autoclass:: async_v20.DecimalNumber
16 | .. autoclass:: async_v20.Direction
17 | .. autoclass:: async_v20.FundingReason
18 | .. autoclass:: async_v20.InstrumentName
19 | .. autoclass:: async_v20.InstrumentType
20 | .. autoclass:: async_v20.LimitOrderReason
21 | .. autoclass:: async_v20.MarketIfTouchedOrderReason
22 | .. autoclass:: async_v20.MarketOrderMarginCloseoutReason
23 | .. autoclass:: async_v20.MarketOrderReason
24 | .. autoclass:: async_v20.OrderCancelReason
25 | .. autoclass:: async_v20.OrderFillReason
26 | .. autoclass:: async_v20.OrderID
27 | .. autoclass:: async_v20.OrderPositionFill
28 | .. autoclass:: async_v20.OrderSpecifier
29 | .. autoclass:: async_v20.OrderState
30 | .. autoclass:: async_v20.OrderStateFilter
31 | .. autoclass:: async_v20.OrderTriggerCondition
32 | .. autoclass:: async_v20.OrderType
33 | .. autoclass:: async_v20.PositionAggregationMode
34 | .. autoclass:: async_v20.PriceComponent
35 | .. autoclass:: async_v20.PriceStatus
36 | .. autoclass:: async_v20.PriceValue
37 | .. autoclass:: async_v20.Reason
38 | .. autoclass:: async_v20.RequestID
39 | .. autoclass:: async_v20.StopLossOrderReason
40 | .. autoclass:: async_v20.StopOrderReason
41 | .. autoclass:: async_v20.TakeProfitOrderReason
42 | .. autoclass:: async_v20.TimeInForce
43 | .. autoclass:: async_v20.TradeID
44 | .. autoclass:: async_v20.TradePL
45 | .. autoclass:: async_v20.TradeSpecifier
46 | .. autoclass:: async_v20.TradeState
47 | .. autoclass:: async_v20.TradeStateFilter
48 | .. autoclass:: async_v20.TrailingStopLossOrderReason
49 | .. autoclass:: async_v20.TransactionFilter
50 | .. autoclass:: async_v20.TransactionID
51 | .. autoclass:: async_v20.TransactionRejectReason
52 | .. autoclass:: async_v20.TransactionType
53 | .. autoclass:: async_v20.WeeklyAlignment
54 | 


--------------------------------------------------------------------------------
/doc/source/response.rst:
--------------------------------------------------------------------------------
 1 | The Response Object
 2 | ===================
 3 | 
 4 | All API methods apart from :meth:`~async_v20.OandaClient.account` and
 5 | :meth:`~async_v20.OandaClient.close_all_trades` return
 6 | :class:`~async_v20.interface.response.Response` objects
 7 | 
 8 | The response object is a :class:`dict` with a few added methods:
 9 | 
10 |     - Truth testing returns true when the Response contains an expected status
11 |     - __repr__ displays all keys
12 | 
13 | 
14 | .. autoclass:: async_v20.interface.response.Response
15 | .. automethod:: async_v20.interface.response.Response.json
16 | .. automethod:: async_v20.interface.response.Response.dict
17 | 
18 | 


--------------------------------------------------------------------------------
/doc/source/traps.rst:
--------------------------------------------------------------------------------
 1 | Traps for young players
 2 | =======================
 3 | 
 4 | Listed here will be traps that have caught me out.
 5 | documented here so it doesn't catch you!
 6 | 
 7 | ERROR!
 8 | ------
 9 | 
10 | Have you written some error handling in the event
11 | the client connection falls over?
12 | 
13 | This is a very broad category of errors.
14 | 
15 | It may be:
16 | 
17 |     - OANDA is down for maintenance
18 |     - Someone unplugged your computer
19 |     - The wifi dropped out
20 |     - Network config issue. IP conflict, routing, firewall...
21 |     - Your token expired (for some reason)
22 | 
23 | An Order is not an OrderRequest
24 | -------------------------------
25 | 
26 | .. note::
27 | 
28 |       This is taken from the OANDA `docs <http://developer.oanda.com/rest-live-v20/order-df/>`_
29 | 
30 |       Orders
31 | 
32 |           - The specification of all Orders supported by the platform.
33 | 
34 |       Order Requests:
35 | 
36 |           - The request specification of all Orders supported by the platform. These objects are used by the API client to create Orders on the platform.
37 | 
38 | They key point here is that you need to use async_v20 objects that derive from
39 | OrderRequest when passing an order request to the order_request argument
40 | of:
41 | 
42 |    :meth:`~async_v20.client.OandaClient.post_order`
43 | 
44 | 


--------------------------------------------------------------------------------
/doc/source/types.rst:
--------------------------------------------------------------------------------
 1 | .. _class-definitions:
 2 | 
 3 | Class Definitions
 4 | =================
 5 | 
 6 | This page contains python class definitions of all types defined in OANDA's
 7 | `docs <http://developer.oanda.com/rest-live-v20/introduction/>`_
 8 | 
 9 | .. toctree::
10 | 
11 |     ./definitions/account
12 |     ./definitions/instrument
13 |     ./definitions/order
14 |     ./definitions/positions
15 |     ./definitions/pricing
16 |     ./definitions/trade
17 |     ./definitions/transaction
18 | 
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/perftests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/perftests/__init__.py


--------------------------------------------------------------------------------
/perftests/creating_arrays.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | from perftests.helpers import Time, client
 3 | 
 4 | print('Running creating_arrays benchmark with async_v20 version', client.version)
 5 | async def creating_arrays(repeats):
 6 |     await asyncio.gather(*[client.get_candles('AUD_USD') for _ in range(repeats)])
 7 | 
 8 | loop = asyncio.get_event_loop()
 9 | with Time() as t:
10 |     loop.run_until_complete(creating_arrays(500))
11 |     loop.run_until_complete(creating_arrays(500))


--------------------------------------------------------------------------------
/perftests/creating_dataframe.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | from perftests.helpers import Time, client
 3 | 
 4 | 
 5 | print('Running creating_dataframes benchmark with async_v20 version', client.version)
 6 | loop = asyncio.get_event_loop()
 7 | 
 8 | rsp = loop.run_until_complete(client.get_candles('AUD_USD'))
 9 | 
10 | 
11 | with Time() as t:
12 |     for _ in range(1000):
13 |         df = rsp.candles.dataframe()


--------------------------------------------------------------------------------
/perftests/creating_orders.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | from perftests.helpers import Time, client
 3 | 
 4 | 
 5 | print('Running creating_dataframe benchmark with async_v20 version', client.version)
 6 | loop = asyncio.get_event_loop()
 7 | 
 8 | # This will test the speed of the _formatting_order_requests helper function
 9 | client.format_order_requests = True
10 | 
11 | async def place_orders(count):
12 |     await asyncio.gather(*[
13 |         client.create_order(
14 |             'AUD_USD',
15 |             units=0,
16 |             stop_loss_on_fill=0,
17 |             take_profit_on_fill=0,
18 |         trailing_stop_loss_on_fill=0,
19 |         )
20 |     for _ in range(count)])
21 | 
22 | 
23 | with Time() as t:
24 |     for _ in range(10):
25 |         loop.run_until_complete(place_orders(500))


--------------------------------------------------------------------------------
/perftests/helpers.py:
--------------------------------------------------------------------------------
 1 | from time import time
 2 | from async_v20 import OandaClient
 3 | 
 4 | class Time(object):
 5 |     def __enter__(self):
 6 |         self.start = time()
 7 |         return self
 8 | 
 9 |     def __exit__(self, exc_type, exc_val, exc_tb):
10 |         self.end = time()
11 |         print(f'Took {self.end - self.start}')
12 | 
13 | 
14 | client = OandaClient(rest_host='127.0.0.1', rest_port=8080, rest_scheme='http',
15 |                      stream_host='127.0.0.1', stream_port=8080, stream_scheme='http',
16 |                      health_host='127.0.0.1', health_port=8080, health_scheme='http',
17 |                      rest_timeout=60, max_simultaneous_connections=1000, max_requests_per_second=99999,
18 |                      token='')


--------------------------------------------------------------------------------
/perftests/rest_implementation.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | from perftests.helpers import Time, client
 3 | 
 4 | print('Running rest_implementation benchmark with async_v20 version', client.version)
 5 | async def rest_implementation(repeats):
 6 |     for _ in range(repeats):
 7 |         account = await client.account()
 8 |         account.json()
 9 | 
10 | loop = asyncio.get_event_loop()
11 | with Time() as t:
12 |     loop.run_until_complete(rest_implementation(1000))


--------------------------------------------------------------------------------
/perftests/server.py:
--------------------------------------------------------------------------------
 1 | from tests.fixtures.routes import routes
 2 | from tests.fixtures.server import rest_headers
 3 | from itertools import cycle
 4 | from perftests.account_changes_json import changes
 5 | import gzip
 6 | from aiohttp import web
 7 | import asyncio
 8 | 
 9 | routes.update({('GET', '/v3/accounts/123-123-1234567-123/changes'): cycle(changes)})
10 | 
11 | async def handler(request):
12 |     method = request.method
13 |     path = request.path.encode('ascii', 'backslashreplace').decode('ascii')
14 |     response = routes[(method, path)]
15 |     json = response
16 |     if not isinstance(json, str):
17 |         json = next(response)
18 |     status = 200
19 |     if method == 'POST':
20 |         status = 201
21 |     return web.Response(body=gzip.compress(bytes(json, encoding='utf8')), headers=rest_headers,
22 |                         status=status)
23 | async def main(loop):
24 |     await loop.create_server(web.Server(handler), "127.0.0.1", 8080)
25 |     print("======= Serving on http://127.0.0.1:8080/ ======")
26 |     await asyncio.sleep(100 * 3600)
27 | 
28 | 
29 | loop = asyncio.get_event_loop()
30 | 
31 | try:
32 |     loop.run_until_complete(main(loop))
33 | except KeyboardInterrupt:
34 |     pass
35 | loop.close()


--------------------------------------------------------------------------------
/readthedocs.yml:
--------------------------------------------------------------------------------
1 | build:
2 |     image: latest
3 | 
4 | python:
5 |    version: 3.6
6 |    pip_install: true
7 | 
8 | requirements_file: requirements.txt
9 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | aiohttp>=3.0.0
 2 | cchardet>=2.1.1
 3 | coverage>=4.4.1
 4 | docutils>=0.14
 5 | pandas
 6 | pytest>=3.2.2
 7 | pytest-asyncio>=0.8.0
 8 | Sphinx>=1.6.4
 9 | ujson>=1.35
10 | yarl>=0.13.0
11 | codecov>=2.0.9
12 | pytest-cov>=2.5.1
13 | sphinx_rtd_theme>=0.2.4
14 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [metadata]
2 | description-file = README.rst


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | from setuptools import setup, find_packages
 4 | from async_v20 import __version__
 5 | 
 6 | 
 7 | def read(f):
 8 |     return open(os.path.join(os.path.dirname(__file__), f)).read().strip()
 9 | 
10 | 
11 | setup(name='async_v20',
12 |       version=__version__,
13 |       description="Asynchronous wrapper for OANDA's v20 REST API",
14 |       long_description=read('README.rst') + '\n\n' + read('CHANGELOG.rst'),
15 |       author='James Peter Schinner',
16 |       author_email='james.peter.schinner@gmail.com',
17 |       url='https://github.com/jamespeterschinner/async_v20',
18 |       license='MIT',
19 |       packages=find_packages(),
20 |       install_requires=['aiohttp>=3.0.0',
21 |                         'ujson>=1.35',
22 |                         'yarl>=0.12.0',
23 |                         'pandas'],
24 |       classifiers=['Programming Language :: Python :: 3.6', 'Development Status :: 4 - Beta',
25 |                    'Framework :: AsyncIO',
26 |                    'Intended Audience :: Developers',
27 |                    'License :: OSI Approved :: MIT License',
28 |                    'Operating System :: OS Independent',
29 |                    'Topic :: Internet :: WWW/HTTP :: Session'],
30 |       keywords='algorithmic trading oanda v20 REST asyncio ',
31 |       )
32 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
1 | import logging
2 | logger = logging.getLogger('async_v20')
3 | logger.disabled = True


--------------------------------------------------------------------------------
/tests/data/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/tests/data/__init__.py


--------------------------------------------------------------------------------
/tests/fixtures/__init__.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from .routes import routes
 4 | from .static import account_changes_response, account_changes_response_two
 5 | from .static import no_open_trades_response
 6 | from .static import list_open_trades_response
 7 | from .static import list_services_response
 8 | from .static import list_services_bad_response
 9 | 
10 | @pytest.fixture
11 | def changes_response_two():
12 |     routes.update({('GET', '/v3/accounts/123-123-1234567-123/changes'): account_changes_response_two})
13 |     yield
14 |     routes.update({('GET', '/v3/accounts/123-123-1234567-123/changes'): account_changes_response})
15 | 
16 | @pytest.fixture
17 | def all_trades_closed():
18 |     routes.update({('GET', '/v3/accounts/123-123-1234567-123/openTrades'): no_open_trades_response})
19 |     yield
20 |     routes.update({('GET', '/v3/accounts/123-123-1234567-123/openTrades'): list_open_trades_response})
21 | 
22 | @pytest.fixture
23 | def all_trades_open_closed():
24 |     def list_trades_response():
25 |         yield list_open_trades_response
26 |         yield no_open_trades_response
27 |     routes.update({('GET', '/v3/accounts/123-123-1234567-123/openTrades'): list_trades_response()})
28 |     yield
29 |     routes.update({('GET', '/v3/accounts/123-123-1234567-123/openTrades'): list_open_trades_response})
30 | 
31 | @pytest.fixture
32 | def services_down():
33 |     routes.update({('GET', '/api/v1/services'): list_services_bad_response})
34 |     yield
35 |     routes.update({('GET', '/api/v1/services'): list_services_response})


--------------------------------------------------------------------------------
/tests/fixtures/client.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import asyncio
 3 | from async_v20.client import OandaClient
 4 | 
 5 | 
 6 | @pytest.yield_fixture
 7 | @pytest.mark.asyncio
 8 | async def client():
 9 |     oanda_client = OandaClient(rest_host='127.0.0.1', rest_port=8080, rest_scheme='http',
10 |                                stream_host='127.0.0.1', stream_port=8080, stream_scheme='http',
11 |                                health_host='127.0.0.1', health_port=8080, health_scheme='http')
12 |     yield oanda_client
13 |     await oanda_client.close()
14 |     await asyncio.sleep(0)
15 | 


--------------------------------------------------------------------------------
/tests/fixtures/routes.py:
--------------------------------------------------------------------------------
 1 | from .static import *
 2 | 
 3 | routes = {
 4 |     ('GET', '/v3/accounts'): list_accounts_response,
 5 |     ('GET', '/v3/accounts/123-123-1234567-123'): get_account_details_response,
 6 |     ('GET', '/v3/accounts/123-123-1234567-123/summary'): account_summary_response,
 7 |     ('GET', '/v3/accounts/123-123-1234567-123/instruments'): account_instruments_response,
 8 |     ('PATCH', '/v3/accounts/123-123-1234567-123/configuration'): None,
 9 |     ('GET', '/v3/accounts/123-123-1234567-123/changes'): account_changes_response,
10 |     ('GET', '/v3/instruments/AUD_USD/candles'): get_candles_response,
11 |     ('POST', '/v3/accounts/123-123-1234567-123/orders'): create_order_response,
12 |     ('GET', '/v3/accounts/123-123-1234567-123/orders'): list_orders_response,
13 |     ('GET', '/v3/accounts/123-123-1234567-123/pendingOrders'): None,
14 |     ('GET', '/v3/accounts/123-123-1234567-123/orders/123-123-1234567-123/'): None,
15 |     ('PUT', '/v3/accounts/123-123-1234567-123/orders/123-123-1234567-123/'): None,
16 |     ('PUT', '/v3/accounts/123-123-1234567-123/orders/0000/cancel'): None,
17 |     ('PUT', '/v3/accounts/123-123-1234567-123/orders/0000/clientExtensions'): None,
18 |     ('GET', '/v3/accounts/123-123-1234567-123/positions'): list_positions_response,
19 |     ('GET', '/v3/accounts/123-123-1234567-123/openPositions'): None,
20 |     ('GET', '/v3/accounts/123-123-1234567-123/positions/0000'): None,
21 |     ('PUT', '/v3/accounts/123-123-1234567-123/positions/AUD_USD/close'): close_position_response,
22 |     ('GET', '/v3/accounts/123-123-1234567-123/pricing'): get_pricing_response,
23 |     ('GET', '/v3/accounts/123-123-1234567-123/pricing/stream'): price_stream,
24 |     ('GET', '/v3/accounts/123-123-1234567-123/trades'): None,
25 |     ('GET', '/v3/accounts/123-123-1234567-123/openTrades'): list_open_trades_response,
26 |     ('GET', '/v3/accounts/123-123-1234567-123/trades/0000'): None,
27 |     ('PUT', '/v3/accounts/123-123-1234567-123/trades/0000/close'): close_all_trades_response,
28 |     ('PUT', '/v3/accounts/123-123-1234567-123/trades/0000/clientExtensions'): None,
29 |     ('PUT', '/v3/accounts/123-123-1234567-123/trades/0000/orders'): None,
30 |     ('GET', '/v3/accounts/123-123-1234567-123/transactions'): None,
31 |     ('GET', '/v3/accounts/123-123-1234567-123/transactions/0000'): None,
32 |     ('GET', '/v3/accounts/123-123-1234567-123/transactions/idrange'): None,
33 |     ('GET', '/v3/accounts/123-123-1234567-123/transactions/sinceid'): None,
34 |     ('GET', '/v3/accounts/123-123-1234567-123/transactions/stream'): None,
35 |     ('GET', '/v3/users/123-123-1234567-123'): None,
36 |     ('GET', '/v3/users/123-123-1234567-123/externalInfo'): None,
37 |     ('GET', '/api/v1/services'): list_services_response,
38 |     ('GET', '/api/v1/services/0000'): get_service_response,
39 |     ('GET', '/api/v1/service-lists'): list_service_lists_response,
40 |     ('GET', '/api/v1/service-lists/0000'): get_service_list_response,
41 |     ('GET', '/api/v1/services/0000/events'): list_events_response,
42 |     ('GET', '/api/v1/services/0000/events/current'): get_current_event_response,
43 |     ('GET', '/api/v1/services/0000/events/0000'): get_event_response,
44 |     ('GET', '/api/v1/statuses'): list_statuses_response,
45 |     ('GET', '/api/v1/statuses/0000'): get_status_response,
46 |     ('GET', '/api/v1/status-images'): list_images_response
47 | }
48 | 


--------------------------------------------------------------------------------
/tests/fixtures/server.py:
--------------------------------------------------------------------------------
  1 | import asyncio
  2 | import gzip
  3 | import re
  4 | from inspect import isgenerator
  5 | 
  6 | import pytest
  7 | from aiohttp import web
  8 | 
  9 | from .routes import routes
 10 | 
 11 | rest_headers = {'Access-Control-Allow-Headers': 'Authorization, Content-Type, Accept-Datetime-Format',
 12 |                 'Access-Control-Allow-Methods': 'PUT, PATCH, POST, GET, OPTIONS, DELETE',
 13 |                 'Access-Control-Allow-Origin': '*',
 14 |                 'Content-Type': 'application/json', 'RequestID': '42359369470976686', 'Content-Encoding': 'gzip',
 15 |                 'Vary': 'Accept-Encoding', 'Connection': 'Keep-Alive'}
 16 | 
 17 | stream_headers = {'Access-Control-Allow-Headers': 'Authorization, Content-Type, Accept-Datetime-Format',
 18 |                   'Access-Control-Allow-Methods': 'PUT, PATCH, POST, GET, OPTIONS, DELETE',
 19 |                   'Access-Control-Allow-Origin': '*',
 20 |                   'Content-Type': 'application/json', 'RequestID': '42359369470976686',
 21 |                   'Vary': 'Accept-Encoding', 'Connection': 'Keep-Alive'}
 22 | 
 23 | status = 200
 24 | received = ''
 25 | sleep_time = 0
 26 | 
 27 | 
 28 | def get_id_from_path(path):
 29 |     try:
 30 |         path_id = re.findall(r'(?<=\/)(\d+)(?=(\/|\Z))', path)[0][0]
 31 |         path = re.sub(r'(?<=\/)(\d+)(?=(\/|\Z))', '0000', path)
 32 |     except:
 33 |         return path, None
 34 |     else:
 35 |         return path, path_id
 36 | 
 37 | 
 38 | def get_response_data(method, path, specifier):
 39 |     data = 'null'
 40 |     try:
 41 |         data = routes[(method, path)]
 42 |     except KeyError:
 43 |         pass
 44 |     if isgenerator(data):  # Allows test to mock changing response
 45 |         data = next(data)
 46 |     if isinstance(data, dict):
 47 |         data = data[int(specifier)]
 48 | 
 49 |     return data
 50 | 
 51 | 
 52 | def get_response_status():
 53 |     global status
 54 |     try:
 55 |         response_status = next(status)
 56 |     except:
 57 |         response_status = status
 58 |     return response_status
 59 | 
 60 | 
 61 | async def handler(request):
 62 |     method = request.method
 63 |     path = request.path.encode('ascii', 'backslashreplace').decode('ascii')
 64 |     path, path_id = get_id_from_path(path)
 65 | 
 66 |     response_data = get_response_data(method, path, path_id)
 67 | 
 68 |     response_status = get_response_status()
 69 | 
 70 |     global received
 71 |     received = await request.read()
 72 | 
 73 |     if response_data is None:
 74 |         response_data = 'null'
 75 | 
 76 |     if path == '/v3/accounts/123-123-1234567-123/pricing/stream':
 77 |         resp = web.StreamResponse(headers=stream_headers,
 78 |                                   status=response_status,
 79 |                                   reason='OK')
 80 |         await resp.prepare(request)
 81 |         while True:
 82 |             await resp.write(bytes(response_data, encoding='utf8'))
 83 |             await resp.write(bytes('\n', encoding='utf8'))
 84 | 
 85 |             await asyncio.sleep(sleep_time)
 86 |     await asyncio.sleep(sleep_time)
 87 |     return web.Response(body=gzip.compress(bytes(response_data, encoding='utf8')), headers=rest_headers,
 88 |                         status=response_status)
 89 | 
 90 | 
 91 | @pytest.yield_fixture
 92 | @pytest.mark.asyncio
 93 | async def server(event_loop):
 94 |     global status, sleep_time
 95 |     status = 200
 96 |     sleep_time = 0
 97 |     server = await event_loop.create_server(web.Server(handler), "127.0.0.1", 8080)
 98 |     yield server
 99 |     server.close()
100 |     await asyncio.sleep(0)
101 | 


--------------------------------------------------------------------------------
/tests/test_definitions/__init__.py:
--------------------------------------------------------------------------------
1 | import logging
2 | logger = logging.getLogger('async_v20')
3 | logger.disabled = True


--------------------------------------------------------------------------------
/tests/test_definitions/helpers.py:
--------------------------------------------------------------------------------
 1 | from inspect import signature, _empty
 2 | from async_v20.definitions.primitives import InstrumentName
 3 | from async_v20.definitions.types import DateTime
 4 | from async_v20.definitions.base import Model, Array
 5 | from async_v20.endpoints.annotations import Bool, FromTime, ToTime
 6 | import logging
 7 | logger = logging.getLogger('async_v20')
 8 | logger.disabled = True
 9 | 
10 | def create_cls_annotations(cls):
11 |     return {name: param.annotation for
12 |             name, param in
13 |             signature(cls.__init__).parameters.items()}
14 | 
15 | 
16 | def get_valid_primitive_data(primitive):
17 |     data = None
18 |     if primitive == _empty:
19 |         return
20 |     elif issubclass(primitive, DateTime): #or primitive == FromTime or primitive == ToTime:
21 |         # Means it is a time
22 |         return '2017-12-19T21:27:45.000000000Z'
23 |     elif issubclass(primitive, Array):
24 |         return (get_valid_primitive_data(primitive._contains),)
25 |     elif issubclass(primitive, Model):
26 |         return {attr: get_valid_primitive_data(create_cls_annotations(primitive)[attr])
27 |                 for attr in primitive.__annotations__}
28 |     elif issubclass(primitive, InstrumentName):
29 |         return 'AUD_USD'
30 |     if issubclass(primitive, (float)):
31 |         data = 14.0
32 |     elif issubclass(primitive, (int)):
33 |         try:
34 |             data = primitive()  # See if the annotation has a default value
35 |         except TypeError:
36 |             data = 123456789
37 |     elif issubclass(primitive, (Bool, dict)):
38 |         # dict covers ArrayDict used for `tags` attribute of Instrument class
39 |         data = primitive()
40 |     # The only valid option here should be a subclass of str
41 |     else:
42 | 
43 |         assert issubclass(primitive, (str))
44 | 
45 |         try:
46 |             data = primitive.example
47 |         except AttributeError:
48 |             try:
49 |                 data = next(iter(primitive.values))
50 |             except AttributeError:
51 |                 data = '1'
52 | 
53 |     return data
54 | 


--------------------------------------------------------------------------------
/tests/test_definitions/test_attributes.py:
--------------------------------------------------------------------------------
 1 | from async_v20.definitions.attributes import *
 2 | import logging
 3 | logger = logging.getLogger('async_v20')
 4 | logger.disabled = True
 5 | 
 6 | def test_keys_in_json_attributes_are_lowercase():
 7 |     assert all(str.islower(i) for i in json_attributes)
 8 | 
 9 | 
10 | def test_values_in_instance_attributes_are_lowercase():
11 |     assert all(str.islower(i) for i in instance_attributes.values())
12 | 
13 | 
14 | def test_every_value_in_instance_attributes_is_a_key_in_json_attributes():
15 |     assert all(i in json_attributes for i in instance_attributes.values())
16 | 


--------------------------------------------------------------------------------
/tests/test_definitions/test_health_types.py:
--------------------------------------------------------------------------------
 1 | from ..data.json_data import list_service_lists_response, list_images_response
 2 | from async_v20.definitions.health_types import ArrayServiceList, ArrayImage
 3 | import json
 4 | 
 5 | import logging
 6 | logger = logging.getLogger('async_v20')
 7 | logger.disabled = True
 8 | 
 9 | 
10 | def test_array_service_lists_constructs():
11 |     data = json.loads(list_service_lists_response)
12 |     array = ArrayServiceList(*data['lists'])
13 |     for i in array:
14 |         r = i.dict()
15 | 
16 | 
17 | def test_array_image_lists_constructs():
18 |     array = ArrayImage(*json.loads(list_images_response)['images'])
19 |     for i in array:
20 |         r = i.dict()


--------------------------------------------------------------------------------
/tests/test_definitions/test_helpers.py:
--------------------------------------------------------------------------------
 1 | from async_v20.definitions.base import Array
 2 | from async_v20.definitions.helpers import flatten_dict
 3 | from async_v20.definitions.primitives import AccountID, TradeID
 4 | from async_v20.endpoints.annotations import Smooth, Count
 5 | from .helpers import get_valid_primitive_data
 6 | import logging
 7 | logger = logging.getLogger('async_v20')
 8 | logger.disabled = True
 9 | 
10 | nested_dict = {'a': {'b': 2, 'c': {'d': 4}}}
11 | flattened_dict = {'a_b': 2, 'a_c_d': 4}
12 | 
13 | 
14 | def test_flatten_dict():
15 |     result = flatten_dict(nested_dict, delimiter='_')
16 |     assert result == flattened_dict
17 | 
18 | 
19 | def test_get_valid_primitive_data_returns_primitive_example():
20 |     assert AccountID.example == get_valid_primitive_data(AccountID)
21 | 
22 | 
23 | def test_get_valid_primitive_data_returns_int():
24 |     assert type(get_valid_primitive_data(TradeID)) == int
25 | 
26 | 
27 | def test_get_valid_primitive_data_returns_bool():
28 |     assert type(get_valid_primitive_data(Smooth)) == bool
29 | 
30 | 
31 | def test_get_valid_primitive_data_returns_default_value():
32 |     assert get_valid_primitive_data(Count) == 500
33 | 
34 | 
35 | def test_get_valid_primitive_data_returns_Array_example():
36 |     class TestArray(Array, contains=AccountID):
37 |         pass
38 | 
39 |     assert (AccountID.example,) == get_valid_primitive_data(TestArray)
40 | 


--------------------------------------------------------------------------------
/tests/test_definitions/test_types.py:
--------------------------------------------------------------------------------
  1 | import pytest
  2 | 
  3 | from async_v20.definitions import types
  4 | from async_v20.definitions.base import Model
  5 | from async_v20.definitions.base import create_attribute
  6 | from async_v20.definitions.types import OrderRequest
  7 | from tests.test_definitions.helpers import get_valid_primitive_data, create_cls_annotations
  8 | from async_v20.exceptions import UnknownKeywordArgument, InstantiationFailure
  9 | import logging
 10 | logger = logging.getLogger('async_v20')
 11 | logger.disabled = True
 12 | 
 13 | model_classes = (cls for cls in (getattr(types, typ) for typ in types.__all__) if
 14 |                  issubclass(cls, Model))
 15 | 
 16 | model_classes_data = [(cls, get_valid_primitive_data(cls)) for cls in model_classes]
 17 | 
 18 | 
 19 | @pytest.mark.parametrize('cls, data', model_classes_data)
 20 | def test_all_order_requests_have_an_instrument_parameter(cls, data):
 21 |     if issubclass(cls, OrderRequest):
 22 |         assert hasattr(cls, 'instrument')
 23 | 
 24 |         result = cls(**data)
 25 |         assert getattr(result, 'instrument')
 26 | 
 27 | @pytest.mark.parametrize('cls, data', model_classes_data)
 28 | def test_class_annotations_match_the_parents_class_annotations(cls, data):
 29 |     if not cls.__bases__[0] == Model:
 30 | 
 31 | 
 32 | 
 33 |         for annotation in cls.__init__.__annotations__:
 34 |             assert annotation in cls.__bases__[0].__init__.__annotations__
 35 | 
 36 | 
 37 | @pytest.mark.parametrize('cls, data', model_classes_data)
 38 | def test_all_types_can_be_instantiated_from_dict(cls, data):
 39 |     arguments = data
 40 |     result = cls(**arguments)
 41 |     assert result
 42 |     assert type(result) == cls
 43 |     # Test class instance can be used to create another instance of the same class
 44 |     result = cls(**result.dict())
 45 |     assert result
 46 |     assert type(result) == cls
 47 | 
 48 | 
 49 | @pytest.mark.parametrize('cls, data', model_classes_data)
 50 | def test_all_types_instantiated_from_dict_with_incorrect_argument_raises_error(cls, data):
 51 |     arguments = data.copy()
 52 |     arguments.update(this_argument_doesnt_exist='TEST_VALUE')
 53 |     with pytest.warns(UnknownKeywordArgument):
 54 |         cls(**arguments)
 55 | 
 56 | 
 57 | @pytest.mark.parametrize('cls, data', model_classes_data)
 58 | def test_all_types_can_be_instantiated_from_tuple(cls, data):
 59 |     arguments = tuple(data.values())
 60 |     # make sure the arguments are in the correct order
 61 |     result = cls(*arguments)
 62 |     result_json = result.json(datetime_format='UNIX')
 63 |     assert result
 64 |     assert type(result) == cls
 65 | 
 66 |     for index, argument in enumerate(arguments):
 67 |         if isinstance(argument, dict):
 68 | 
 69 |             args = list(arguments)
 70 |             args[index] = tuple(argument.values())
 71 |             result = cls(*args).json(datetime_format='UNIX')
 72 | 
 73 | 
 74 |             assert result == result_json
 75 | 
 76 | 
 77 | @pytest.mark.parametrize('cls, data', model_classes_data)
 78 | def test_all_types_can_be_instantiated_from_annotation(cls, data):
 79 |     arguments = {k: create_attribute(create_cls_annotations(cls)[k], v)
 80 |                  for k, v in data.items()}
 81 | 
 82 |     assert cls(**arguments)
 83 | 
 84 | @pytest.mark.parametrize('cls, data', model_classes_data)
 85 | def test_all_derived_types_have_same_arguments_and_annotations_as_parent(cls, data):
 86 |     parent_class = cls.__bases__[0]
 87 |     if not parent_class == Model:
 88 |         parent_class_parameters = parent_class.__init__.__signature__.parameters
 89 |         for name, parameter in cls.__init__.__signature__.parameters.items():
 90 |             assert name in parent_class_parameters
 91 |             try:
 92 |                 assert issubclass(parameter.annotation,parent_class_parameters[name].annotation)
 93 |             except TypeError:
 94 |                 # means annotation is async_v20.definitions.helpers.time function
 95 |                 assert parameter.annotation == parent_class_parameters[name].annotation
 96 | 
 97 | @pytest.mark.parametrize('cls, data', model_classes_data)
 98 | def test_instances_are_immutable(cls, data):
 99 |     instance = cls(**data)
100 |     with pytest.raises(NotImplementedError):
101 |         setattr(instance, instance._fields[0], None)
102 | 
103 |     with pytest.raises(NotImplementedError):
104 |         delattr(instance, instance._fields[0])
105 | 
106 | @pytest.mark.parametrize('cls, data', model_classes_data)
107 | def test_warning_when_unknown_kwargs_are_passed_to_class(cls, data):
108 |     with pytest.warns(UnknownKeywordArgument):
109 |         try:
110 |             cls(**data, o=1) # doubled up argument for CandlestickData
111 |         except TypeError:
112 |             cls(**data, instrument='AUD_USD')
113 | 
114 | 


--------------------------------------------------------------------------------
/tests/test_endpoints/__init__.py:
--------------------------------------------------------------------------------
1 | import logging
2 | logger = logging.getLogger('async_v20')
3 | logger.disabled = True


--------------------------------------------------------------------------------
/tests/test_endpoints/test_annotations.py:
--------------------------------------------------------------------------------
 1 | import random
 2 | 
 3 | import pytest
 4 | 
 5 | from async_v20.endpoints import annotations
 6 | import logging
 7 | logger = logging.getLogger('async_v20')
 8 | logger.disabled = True
 9 | 
10 | 
11 | def test_count_only_allows_valid_data():
12 |     with pytest.raises(ValueError):
13 |         annotations.Count(0)
14 | 
15 |     with pytest.raises(ValueError):
16 |         annotations.Count(5001)
17 | 
18 |     assert annotations.Count(random.randrange(1, 5001))
19 | 
20 |     assert int(annotations.Count()) == 500
21 | 
22 | 
23 | def test_daily_alignment_only_allows_valid_data():
24 |     with pytest.raises(ValueError):
25 |         annotations.DailyAlignment(-1)
26 | 
27 |     with pytest.raises(ValueError):
28 |         annotations.DailyAlignment(24)
29 | 
30 |     assert annotations.Count(random.randrange(1, 23))
31 | 
32 |     assert int(annotations.DailyAlignment()) == 17
33 | 
34 | 
35 | def test_page_size_only_allows_valid_data():
36 |     with pytest.raises(ValueError):
37 |         annotations.PageSize(-1)
38 | 
39 |     with pytest.raises(ValueError):
40 |         annotations.PageSize(1001)
41 | 
42 |     assert annotations.Count(random.randrange(1, 1000))
43 | 
44 |     assert int(annotations.PageSize()) == 100
45 | 
46 | 
47 | def test_alignment_time_zone_only_allows_valid_data():
48 |     assert annotations.AlignmentTimezone() == 'America/New_York'
49 | 
50 | 
51 | def test_smooth_returns_correct_default_data():
52 |     assert annotations.Smooth() == False
53 | 


--------------------------------------------------------------------------------
/tests/test_interface/__init__.py:
--------------------------------------------------------------------------------
1 | import logging
2 | logger = logging.getLogger('async_v20')
3 | logger.disabled = True


--------------------------------------------------------------------------------
/tests/test_interface/helpers.py:
--------------------------------------------------------------------------------
 1 | import ujson as json
 2 | def sort_json(x):
 3 |     return json.dumps(json.loads(x), sort_keys=True)
 4 | 
 5 | def order_dict(obj):
 6 |     if isinstance(obj, dict):
 7 |         return sorted((k, order_dict(v)) for k, v in obj.items())
 8 |     if isinstance(obj, list):
 9 |         return sorted(order_dict(x) for x in obj)
10 |     else:
11 |         return obj
12 | 


--------------------------------------------------------------------------------
/tests/test_interface/test_api_methods.py:
--------------------------------------------------------------------------------
 1 | import inspect
 2 | 
 3 | import pytest
 4 | from aiohttp.client_exceptions import ServerDisconnectedError, ContentTypeError
 5 | 
 6 | from async_v20 import OandaClient
 7 | from tests.test_definitions.helpers import get_valid_primitive_data
 8 | from ..fixtures import server as server_module
 9 | from ..fixtures.client import client
10 | from async_v20.exceptions import UnexpectedStatus
11 | from async_v20 import InstrumentName
12 | import logging
13 | logger = logging.getLogger('async_v20')
14 | logger.disabled = True
15 | 
16 | client = client
17 | server = server_module.server
18 | received = server_module.received
19 | 
20 | 
21 | @pytest.mark.asyncio
22 | @pytest.mark.parametrize('method', inspect.getmembers(OandaClient, lambda x: hasattr(x, 'endpoint')))
23 | async def test_client_initializes_automatically_with_every_api_method(method, server, client):
24 |     client.format_order_requests = True
25 |     global received
26 |     global status
27 | 
28 |     data = tuple(get_valid_primitive_data(param.annotation)
29 |                  for param in method[1].__signature__.parameters.values()
30 |                  if param.name != 'self')
31 |     status = 200
32 |     method = getattr(client, method[0])
33 |     try:
34 |         resp = await method(*data)
35 |     except (KeyError, ServerDisconnectedError, ContentTypeError, AttributeError, UnexpectedStatus):
36 |         pass  # Caused by incorrect response status being returned
37 |         # Server not keeping a data stream open
38 |         # Response Not containing expected data
39 |     if getattr(method, 'initialize_required', True):
40 |         assert client.initialized
41 |     else:
42 |         assert not client.initialized
43 | 
44 | 
45 | @pytest.mark.asyncio
46 | @pytest.mark.parametrize('method', inspect.getmembers(OandaClient, lambda x: hasattr(x, 'endpoint')))
47 | async def test_client_methods_send_correct_data(method, server, client):
48 |     client.format_order_requests = True
49 |     data = tuple(get_valid_primitive_data(param.annotation)
50 |                  for param in method[1].__signature__.parameters.values()
51 |                  if param.name != 'self')
52 |     async with client as client:  # initialize first
53 |         method = getattr(client, method[0])
54 |         server_module.status = next(iter(method.endpoint.responses))
55 |         try:
56 |             resp = await method(*data)
57 |         except (KeyError, ServerDisconnectedError, ContentTypeError, AttributeError):
58 |             pass  # Caused by incorrect response status being returned
59 |             # Server not keeping a data stream open
60 |             # Response Not containing expected data
61 |         # TODO Added meaning full asserts
62 | 
63 | 
64 | @pytest.mark.asyncio
65 | @pytest.mark.parametrize('method', inspect.getmembers(OandaClient, lambda x: hasattr(x, 'shortcut')))
66 | async def test_client_methods_shortcut_api_methods(method, server, client):
67 |     client.format_order_requests = True
68 |     data = tuple(get_valid_primitive_data(param.annotation)
69 |                  for param in method[1].__signature__.parameters.values()
70 |                  if param.name not in 'self cls')
71 |     async with client as client:  # initialize first
72 |         method = getattr(client, method[0])
73 |         server_module.status = 201
74 | 
75 | 
76 |         try:
77 |             resp = await method(*data)
78 |         except (KeyError, ServerDisconnectedError, ContentTypeError, AttributeError):
79 |             pass  # Caused by incorrect response status being returned
80 |             # Server not keeping a data stream open
81 |             # Response Not containing expected data
82 |         # TODO Added meaning full asserts
83 | 
84 | 
85 | @pytest.mark.asyncio
86 | async def test_get_pricing_accepts_instrument_name(server, client):
87 |     await client.get_pricing(InstrumentName('AUD_USD'))
88 | 


--------------------------------------------------------------------------------
/tests/test_interface/test_docstrings.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from async_v20 import interface
 3 | from inspect import Parameter
 4 | import logging
 5 | logger = logging.getLogger('async_v20')
 6 | logger.disabled = True
 7 | 
 8 | @pytest.mark.parametrize('interface_method', [method for cls in (getattr(interface, cls) for cls in interface.__all__)
 9 |                                               for method in cls.__dict__.values() if hasattr(method, 'endpoint')])
10 | def test_interface_docstrings_have_all_arguments(interface_method):
11 | 
12 | 
13 |     sig_names = {name: value for name, value in interface_method.__signature__.parameters.items()
14 |                  if name != 'self'}
15 |     # Call the wrapped method, we are testing the only thing inside method
16 |     # in this test. So may as well do this to improve coverage
17 |     interface_method.__wrapped__(*list(range(len(sig_names) + 1)))
18 |     for key in sig_names:
19 |         assert key in interface_method.__doc__
20 | 
21 |     # Due to the interface method only being used for defining the interface to the endpoint and is done
22 |     # by creating an annotated signature, the actually method will never be called. Meaning that tests
23 |     # will never have 100% coverage.
24 | 
25 |     # The above test is the closest test that resembles the the purpose of the api method, There we will
26 |     # call the method simply to gain test coverage.
27 | 
28 |     interface_method.__wrapped__(*list(range(len(sig_names) + 1)))  # +1 self
29 | 


--------------------------------------------------------------------------------
/tests/test_interface/test_response.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from tests.fixtures.static import get_account_details_response, get_pricing_response, list_accounts_response
 3 | from async_v20.interface.response import Response
 4 | from async_v20.definitions.base import Model, Array
 5 | from async_v20.definitions.types import ArrayStr
 6 | from ..fixtures.client import client
 7 | from ..fixtures import server as server_module
 8 | from .helpers import sort_json
 9 | import asyncio
10 | 
11 | import logging
12 | logger = logging.getLogger('async_v20')
13 | logger.disabled = True
14 | 
15 | client = client
16 | server = server_module.server
17 | 
18 | 
19 | 
20 | @pytest.mark.asyncio
21 | async def test_response_creates_correct_json(client, server):
22 |     server_module.status = 200
23 |     async with client as client:
24 |         response = await client.get_account_details()
25 |         resp_json = response.json()
26 | 
27 |         correct = get_account_details_response.replace(' ', '')
28 |         assert sort_json(resp_json) == sort_json(correct)
29 | 
30 | 
31 | @pytest.mark.asyncio
32 | async def test_response_returns_json(client, server):
33 |     async with client as client:
34 |         accounts = await client.list_accounts()
35 |         account_details = await client.get_account_details()
36 |         pricing = await client.get_pricing()
37 | 
38 |     assert sort_json(accounts.json()) == sort_json(list_accounts_response.replace(' ', ''))
39 |     assert sort_json(account_details.json()) == sort_json(get_account_details_response.replace(' ', ''))
40 |     assert sort_json(pricing.json()) == sort_json(get_pricing_response.replace(' ', ''))
41 | 
42 | @pytest.mark.asyncio
43 | async def test_response_keys_can_be_accessed_through_dot(client, server):
44 |     async with client as client:
45 |         accounts = await client.list_accounts()
46 |         account_details = await client.get_account_details()
47 |         pricing = await client.get_pricing()
48 | 
49 |     for response in [accounts, account_details, pricing]:
50 |         for key, value in response.items():
51 |             assert getattr(response, key) == value
52 |             with pytest.raises(AttributeError):
53 |                 getattr(response, key+'_test')
54 | 
55 | def test_response_doesnt_error_when_response_contains_no_data():
56 |     result = Response(None, 400, True, 'UNIX')
57 | 
58 | @pytest.mark.asyncio
59 | async def test_response_repr(client, server):
60 |     with client as client:
61 |         rsp = await client.get_candles('AUD_USD')
62 |         repr(rsp)
63 | 
64 | @pytest.mark.asyncio
65 | async def test_response_dict(client, server):
66 |     def check_types(item):
67 |         for value in item.values():
68 |             if isinstance(value, dict):
69 |                 check_types(value)
70 |             assert not isinstance(value, (Model, Array))
71 | 
72 |     async with client as client:
73 |         for rsp in await asyncio.gather(
74 |                 client.get_account_details(),
75 |                 client.get_candles('AUD_USD'),
76 |                 client.list_accounts(),
77 |                 client.list_services(),
78 |                 client.list_open_trades(),
79 |             ):
80 |             check_types(rsp.dict())
81 | 
82 |     response = Response({'test': ArrayStr('1','2','3')}, 200, True, 'UNIX')
83 |     check_types(response.dict())


--------------------------------------------------------------------------------
/tests/test_server_fixture.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from .fixtures.client import client
 3 | from .fixtures.server import server
 4 | import logging
 5 | logger = logging.getLogger('async_v20')
 6 | logger.disabled = True
 7 | client = client
 8 | server = server
 9 | 
10 | @pytest.mark.asyncio
11 | async def test_list_services_returns_services(client, server):
12 |     async with client as client:
13 |         rsp = await client.list_services()
14 | 
15 |     assert getattr(rsp, 'services')


--------------------------------------------------------------------------------
/tests/test_type_creation/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jamespeterschinner/async_v20/7538d5af2877131d65febb44f72f39b03dae5b1e/tests/test_type_creation/__init__.py


--------------------------------------------------------------------------------
/tests/test_type_creation/test_object_construction.py:
--------------------------------------------------------------------------------
 1 | from ..data.json_data import GETAccountID_response
 2 | from ..data.json_data import position_response
 3 | from ..data.json_data import order_cancel_transaction_json_dict
 4 | from ..data.json_data import example_order
 5 | from ..data.json_data import account_example
 6 | from ..data.json_data import example_transaction_array
 7 | from ..data.json_data import example_trade_array
 8 | from ..data.json_data import example_market_order_reject_transaction
 9 | from ..data.json_data import example_transaction
10 | 
11 | from async_v20.definitions.types import Position
12 | from async_v20.definitions.types import Instrument
13 | from async_v20.definitions.types import OrderCancelTransaction
14 | from async_v20.definitions.types import ArrayOrder
15 | from async_v20.definitions.types import Account
16 | from async_v20.definitions.types import Order
17 | from async_v20.definitions.types import ArrayTransaction
18 | from async_v20.definitions.types import ArrayTrade
19 | from async_v20.definitions.types import MarketOrderRejectTransaction
20 | from async_v20.definitions.types import Transaction
21 | from async_v20.definitions.primitives import TradeSpecifier
22 | from async_v20.definitions.primitives import OrderSpecifier
23 | from async_v20.definitions.primitives import PriceComponent
24 | from async_v20.exceptions import IncompatibleValue
25 | import pandas as pd
26 | import pytest
27 | from itertools import permutations
28 | 
29 | def test_account_builds_from_dict():
30 |     account_instance = Account(**GETAccountID_response['account'])
31 |     assert type(account_instance) == Account
32 |     series = account_instance.series()
33 |     assert type(series) == pd.Series
34 | 
35 | 
36 | def test_position_builds_from_dict():
37 |     position = Position(**position_response)
38 |     assert type(position) == Position
39 |     series = position.series()
40 |     assert type(series) == pd.Series
41 | 
42 | 
43 | def test_order_cancel_transaction_builds_from_dict():
44 |     order_cancel_transaction = OrderCancelTransaction(**order_cancel_transaction_json_dict)
45 |     assert type(order_cancel_transaction) == OrderCancelTransaction
46 |     series = order_cancel_transaction.series()
47 |     assert type(series) == pd.Series
48 | 
49 | 
50 | def test_supplying_incorret_preset_argument_raises_error():
51 |     order_cancel_transaction_json_dict.update(type='INCORRECT VALUE')
52 |     with pytest.raises(IncompatibleValue):
53 |         OrderCancelTransaction(**order_cancel_transaction_json_dict)
54 | 
55 | def test_passing_empty_list_tuple_to_array_returns_empty_array():
56 |     array_order = ArrayOrder(*[])
57 |     assert type(array_order) == ArrayOrder
58 |     account = Account(orders=[])
59 |     assert type(account.orders) == ArrayOrder
60 |     account = Account(orders=())
61 |     assert type(account.orders) == ArrayOrder
62 | 
63 | def test_specifiers_can_be_constructed_from_int():
64 |     assert type(TradeSpecifier(1234)) == TradeSpecifier
65 |     assert type(OrderSpecifier(1234)) == OrderSpecifier
66 | 
67 | def test_order_can_be_constructed_from_example_data():
68 |     assert type(Order(**example_order)) == Order
69 | 
70 | def test_supplying_incorrect_type_raises_error():
71 |     with pytest.raises(IncompatibleValue):
72 |         result = Order(instrument=Instrument())
73 |         error = result.instrument
74 | 
75 | 
76 | 
77 | def test_account_object_can_be_constructed_from_example():
78 |     assert type(Account(**account_example['account'])) == Account
79 | 
80 | def test_transaction_array_can_be_constructed_from_example():
81 |     assert type(ArrayTransaction(*example_transaction_array)) == ArrayTransaction
82 | 
83 | def test_trade_array_can_be_constructed_from_example():
84 |     assert type(ArrayTrade(*example_trade_array)) == ArrayTrade
85 | 
86 | def test_all_possible_combinations_of_price_component():
87 |     for i in range(1,4):
88 |         for perm in permutations('MBA', i):
89 |             assert type(PriceComponent(perm[0])) == PriceComponent
90 | 
91 | def test_market_order_reject_transaction_can_be_created_from_example():
92 |     assert type(MarketOrderRejectTransaction(**example_market_order_reject_transaction)) == \
93 |         MarketOrderRejectTransaction
94 | 
95 | def test_transaction_can_be_constructed_from_example():
96 |     assert type(Transaction(**example_transaction)) == Transaction


--------------------------------------------------------------------------------