question for hootnot 2

[traveller1011]

CONTEXT

1. imagine a situation where multiple trades are open in the same subaccount, same instrument, and unit quantity... Like this:

2. attempting to close all but one of these open trades will result in order being cancelled for FIFO reasons.

QUESTION

Do you know any tricks to test which trade is "allowed" to be closed per US FIFO law? Or stated differently, given a list of trades, can we determine which ones are NOT eligible to be closed?

I understand I could query for the lowest trade_id among such a group, and that should, by definition, work. But I thought maybe you might know a better way.

This is all the info I see when I query for a trade... nothing lends itself to "can be closed", or im just blind

{
    "trade": {
        "id": "148",
        "instrument": "EUR_USD",
        "price": "1.09190",
        "openTime": "2023-01-26T01:48:04.744487039Z",
        "initialUnits": "-1",
        "initialMarginRequired": "0.0218",
        "state": "OPEN",
        "currentUnits": "-1",
        "realizedPL": "0.0000",
        "financing": "0.0001",
        "dividendAdjustment": "0.0000",
        "unrealizedPL": "0.0057",
        "marginUsed": "0.0217"
    },
    "lastTransactionID": "266"
}

[hootnot]

personally I use PositionClose and close a pos. completely regardless how many trades it took to build the pos.

regarding your JSON response above: if a trade has the state OPEN that also says that it can be closed.

Using TradeClose() with the trade id, you should be able to close a specific trade.

There is also: positions.PositionDetails(accountID=accountID, instrument)
https://oanda-api-v20.readthedocs.io/en/latest/endpoints/positions/positiondetails.html

it gives the tradeids involved regarding a position. In this example 1. But in your case you should see 144, 146, 148

{
  "position": {
    "short": {
      "unrealizedPL": "-0.0738",
      "tradeIDs": [
        "2323"                                   <---------------------------
      ],
      "resettablePL": "0.0000",
      "units": "-100",
      "averagePrice": "1.09843",
      "pl": "0.0000"
    },
    "unrealizedPL": "-0.0738",
    "long": {
      "units": "0",
      "resettablePL": "-44.6272",
      "unrealizedPL": "0.0000",
      "pl": "-44.6272"
    },
    "instrument": "EUR_USD",
    "resettablePL": "-44.6272",
    "pl": "-44.6272"
  },
  "lastTransactionID": "2327"
}

[traveller1011]

Slight issue with this remark:

regarding your JSON response above: if a trade has the state OPEN that also says that it can be closed.

The problem is i have three open trades. And despite the fact the state is "OPEN", only one can be closed at a time.

And because I am a US person, I am subject to FIFO. I imagine you have not had to deal with FIFO. But it means that "if multiple trades are open, in one subaccount, in the same number of units, then the first trade opened must be closed before the others can.

So its kind of an "America" problem.

Also my strategy is clouding the issue... normal people don't open a many trades, in the same instrument, at the same unit qty. And I could easily get around it by opening irregular unit sizes like 2, 3, 4. So let me mess with that.

Also FTR I feel the end game of this strategy WILL be closing the whole position, not certain trades. I have not quite reached that chapter yet.

Thank you again for answering, marketing as answered, thank you!

[hootnot]

Using pydantic you can model the JSON positiondetails response, like:

#!/usr/bin/env python3

from pydantic import BaseModel
from typing import List, Optional
import json

PD = """
{
  "position": {
    "instrument": "EUR_AUD",
    "long": {
      "units": "101000",
      "averagePrice": "1.54219",
      "pl": "-370.5202",
      "resettablePL": "-370.5202",
      "financing": "-10.3198",
      "dividendAdjustment": "0.0000",
      "guaranteedExecutionFees": "0.0000",
      "tradeIDs": [
        "144",
        "146",
        "148"
      ],
      "unrealizedPL": "13.3506"
    },
    "short": {
      "units": "0",
      "pl": "-45385.1328",
      "resettablePL": "-45385.1328",
      "financing": "-227.2849",
      "dividendAdjustment": "0.0000",
      "guaranteedExecutionFees": "0.0000",
      "unrealizedPL": "0.0000"
    },
    "pl": "-82469.6530",
    "resettablePL": "-82469.6530",
    "financing": "-1325.6047",
    "commission": "0.0000",
    "dividendAdjustment": "0.0000",
    "guaranteedExecutionFees": "0.0000",
    "unrealizedPL": "13.3506",
    "marginUsed": "10100.0000"
  },
  "lastTransactionID": "400701"
}

"""
class _Position(BaseModel):
     units: float
     averagePrice: Optional[float]
     pl: float
     resettablePL: float
     financing: float
     dividendAdjustment: float
     guaranteedExecutionFees: float
     tradeIDs: Optional[List[int]]
     unrealizedPL: float

class Long(_Position):
    pass

class Short(_Position):
    pass

class Position(BaseModel):
    instrument: str
    long_: Long
    short_: Short
    pl: float
    resettablePL: float
    financing: float
    commission: float
    dividendAdjustment: float
    guaranteedExecutionFees: float
    unrealizedPL: float
    marginUsed: float

    class Config:
        # to work around the reserved words
        fields = {
            "long_": "long",
            "short_": "short",
        }


if __name__ == '__main__':
    _ = json.loads(PD)
    p = Position(**_["position"])
    print(p.json(indent=2, by_alias=True))
    print(p.long_.tradeIDs)

... the JSON
[144, 146, 148]

[traveller1011]

... so144 can be closed (first in) while the others cant. brilliant....

thank you Hootnot!!

[hootnot]

Since you like the Pydantic concept ... the code below will get you the firstToClose id, without having to check whether the pos. is on the long side or short side

extending the above with:

class PositionDetails(BaseModel):
    position: Position
    lastTransactionID: int

this will consume the JSON response of PositionDetails() like:

pd = PositionDetails(**rv)

The pydantic model can be extended to get the parameters you want as attributes of the model. To get your firstToClose id you can make use of validators, like:

from pydantic import BaseModel, Field, root_validator
from typing import List, Optional
import json
import decimal


class _Position(BaseModel):
    units: float
    averagePrice: Optional[decimal.Decimal]
    pl: decimal.Decimal
    resettablePL: decimal.Decimal
    financing: decimal.Decimal
    dividendAdjustment: decimal.Decimal
    guaranteedExecutionFees: decimal.Decimal
    tradeIDs: Optional[List[int]]
    unrealizedPL: decimal.Decimal


class Long(_Position):
    pass


class Short(_Position):
    pass


class Position(BaseModel):
    instrument: str
    long_: Long
    short_: Short
    pl: float
    resettablePL: decimal.Decimal
    financing: decimal.Decimal
    commission: decimal.Decimal
    dividendAdjustment: decimal.Decimal
    guaranteedExecutionFees: decimal.Decimal
    unrealizedPL: decimal.Decimal
    marginUsed: decimal.Decimal

    class Config:
        fields = {
            "long_": "long",
            "short_": "short",
        }

class PositionDetails(BaseModel):
    position: Position
    lastTransactionID: int
    firstToClose: Optional[int]                 # your extension
    tradeIDs: Optional[List[int]]               # your extension

    @root_validator
    def find_first_to_close(cls, values):
        # print(values)
        def lid():
            # list of id's, both short and/or long
            v = []
            for P in ["long_", "short_"]:
                idl = getattr(values["position"], P).tradeIDs
                if idl:
                    v = v + idl

            return v

        values["tradeIDs"] = sorted(lid())
        if values["tradeIDs"]:
            values["firstToClose"] = values["tradeIDs"][0]
        else:
            values["firstToClose"] = None

        return values

    class Config:
        extra = Extra.forbid

With the response model code in responsemodel.py, you can test it using:

#!/usr/bin/env python

import json
import oandapyV20.endpoints.positions as positions
import responsemodels as rm
from oandapyV20 import API


ACCTID = ""
TOKEN = "..."

if __name__ == '__main__':
    import sys

    client = API(access_token=TOKEN)  # , environment='live')
    r = positions.PositionDetails(accountID=ACCTID,
                                  instrument=sys.argv[1])

    try:
        rv = client.request(r)

    except Exception as err:
        print(err)

    else:
        p = rm.PositionDetails(**rv)
        print(p.json(indent=2, by_alias=True))
        print(p.firstToClose)