tradx 0.1.0__py3-none-any.whl

tradx/baseClass/optionsInstrument.py

@@ -0,0 +1,279 @@
+from decimal import Decimal
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from enum import Enum
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Any
+
+if TYPE_CHECKING:
+    from pandas.core.series import Series
+    from pandas import DataFrame
+
+
+class OptionType(Enum):
+    CE = 3
+    PE = 4
+
+
+def parse_int(value: Any) -> int:
+    if isinstance(value, str):
+        return int(value)
+    return value
+
+
+def captilize_str(value: str) -> str:
+    return value.upper()
+
+
+class OptionsInstrument(BaseModel):
+    ExchangeSegment: str
+    ExchangeInstrumentID: int
+    InstrumentType: int
+    Name: str
+    Description: str
+    Series: str
+    NameWithSeries: str
+    InstrumentID: int
+    PriceBand_High: Decimal
+    PriceBand_Low: Decimal
+    FreezeQty: int
+    TickSize: Decimal
+    LotSize: int
+    Multiplier: Decimal
+    UnderlyingInstrumentId: int
+    UnderlyingIndexName: str
+    ContractExpiration: datetime
+    StrikePrice: Decimal
+    OptionType: Annotated[OptionType, BeforeValidator(parse_int)]
+    DisplayName: str
+    PriceNumerator: int
+    PriceDenominator: int
+    DetailedDescription: str
+
+    class Config:
+        use_enum_values = True
+
+    def __init__(
+        self,
+        ExchangeSegment: str,
+        ExchangeInstrumentID: int,
+        InstrumentType: int,
+        Name: str,
+        Description: str,
+        Series: str,
+        NameWithSeries: str,
+        InstrumentID: int,
+        PriceBand_High: Decimal,
+        PriceBand_Low: Decimal,
+        FreezeQty: int,
+        TickSize: Decimal,
+        LotSize: int,
+        Multiplier: Decimal,
+        UnderlyingInstrumentId: int,
+        UnderlyingIndexName: Annotated[
+            str,
+            BeforeValidator(str, captilize_str),
+        ],
+        ContractExpiration: datetime,
+        StrikePrice: Decimal,
+        OptionType: Any,
+        DisplayName: str,
+        PriceNumerator: int,
+        PriceDenominator: int,
+        DetailedDescription: str,
+    ):
+        super().__init__(
+            ExchangeSegment=ExchangeSegment,
+            ExchangeInstrumentID=ExchangeInstrumentID,
+            InstrumentType=InstrumentType,
+            Name=Name,
+            Description=Description,
+            Series=Series,
+            NameWithSeries=NameWithSeries,
+            InstrumentID=InstrumentID,
+            PriceBand_High=PriceBand_High,
+            PriceBand_Low=PriceBand_Low,
+            FreezeQty=FreezeQty,
+            TickSize=TickSize,
+            LotSize=LotSize,
+            Multiplier=Multiplier,
+            UnderlyingInstrumentId=UnderlyingInstrumentId,
+            UnderlyingIndexName=UnderlyingIndexName,
+            ContractExpiration=ContractExpiration,
+            StrikePrice=StrikePrice,
+            OptionType=OptionType,
+            DisplayName=DisplayName,
+            PriceNumerator=PriceNumerator,
+            PriceDenominator=PriceDenominator,
+            DetailedDescription=DetailedDescription,
+        )
+
+    def __init__(self, df: "Series"):
+        super().__init__(**df)
+
+
+class OptionManager:
+    """
+    Manages a list of options instruments and provides methods to search and filter them.
+    """
+
+    def __init__(self, option_master: "DataFrame"):
+        """
+        Initializes the OptionManager with a DataFrame of options data.
+        Args:
+            option_master (pandas.DataFrame): DataFrame containing options data.
+        """
+        self.__list: List[OptionsInstrument] = []
+        for index, row in option_master.iterrows():
+            self.__list.append(OptionsInstrument(row))
+
+        self.__all_underline = list(
+            set([option.UnderlyingIndexName for option in self.__list])
+        )
+
+    def search_expiry_by_underline(self, underline: str) -> List[datetime]:
+        """
+        Searches for all contract expirations for a given underlying index name.
+        Args:
+            underline (str): The underlying index name to search for.
+        Returns:
+            List[OptionsInstrument.ContractExpiration]: A sorted list of contract expirations.
+        """
+        return sorted(
+            list(
+                set(
+                    option.ContractExpiration
+                    for option in self.__list
+                    if option.UnderlyingIndexName == underline
+                )
+            )
+        )
+
+    def search_all_underline(self) -> List[str]:
+        """
+        Retrieves all unique underlying index names.
+        Returns:
+            List[OptionsInstrument.UnderlyingIndexName]: A list of all unique underlying index names.
+        """
+        return self.__all_underline
+
+    def search_option_by_underline(self, underline: str) -> List[OptionsInstrument]:
+        """
+        Searches for all options instruments for a given underlying index name.
+        Args:
+            underline (str): The underlying index name to search for.
+        Returns:
+            List[OptionsInstrument]: A list of options instruments.
+        """
+        return [
+            option for option in self.__list if option.UnderlyingIndexName == underline
+        ]
+
+    def search_option_by_expiry_underline(
+        self, underline: str, expiry: datetime
+    ) -> List[OptionsInstrument]:
+        """
+        Searches for all options instruments for a given underlying index name and contract expiration.
+        Args:
+            underline (str): The underlying index name to search for.
+            expiry (OptionsInstrument.ContractExpiration): The contract expiration to search for.
+        Returns:
+            List[OptionsInstrument]: A list of options instruments.
+        """
+        return [
+            option
+            for option in self.__list
+            if option.UnderlyingIndexName == underline
+            and option.ContractExpiration == expiry
+        ]
+
+    def search_option(
+        self,
+        ExchangeSegment: str = None,
+        ExchangeInstrumentID: int = None,
+        InstrumentType: int = None,
+        Name: str = None,
+        Series: str = None,
+        UnderlyingIndexName: str = None,
+        ContractExpiration: datetime = None,
+        StrikePrice: int = None,
+        OptionType: int = None,
+        minimumExpiry: bool = False,
+    ) -> List[OptionsInstrument]:
+        """
+        Searches for options based on various criteria.
+        Args:
+            ExchangeSegment (str): Exchange segment to search for.
+            ExchangeInstrumentID (int): Exchange instrument ID to search for.
+            InstrumentType (int): Instrument type to search for.
+            Name (str): Name to search for.
+            Series (str): Series to search for.
+            UnderlyingIndexName (str): Underlying index name to search for.
+            ContractExpiration (datetime): Contract expiration to search for.
+            StrikePrice (int): Strike price to search for.
+            OptionType (int): Option type to search for.
+            minimumExpiry (bool): If True, only return options with the minimum expiration date.
+        Returns:
+            pandas.DataFrame: DataFrame containing the search results.
+        """
+        assert ExchangeSegment is None or isinstance(
+            ExchangeSegment, str
+        ), "ExchangeSegment must be a string"
+        assert ExchangeInstrumentID is None or isinstance(
+            ExchangeInstrumentID, int
+        ), "ExchangeInstrumentID must be an integer"
+        assert InstrumentType is None or isinstance(
+            InstrumentType, int
+        ), "InstrumentType must be an integer"
+        assert Name is None or isinstance(Name, str), "Name must be a string"
+        assert Series is None or isinstance(Series, str), "Series must be a string"
+        assert UnderlyingIndexName is None or isinstance(
+            UnderlyingIndexName, str
+        ), "UnderlyingIndexName must be a string"
+        assert ContractExpiration is None or isinstance(
+            ContractExpiration, datetime
+        ), "ContractExpiration must be a datetime"
+        assert StrikePrice is None or isinstance(
+            StrikePrice, int
+        ), "StrikePrice must be an integer"
+        assert OptionType is None or isinstance(
+            OptionType, int
+        ), "OptionType must be an integer"
+        assert isinstance(minimumExpiry, bool), "minimumExpiry must be a boolean"
+
+        criteria = {
+            "ExchangeSegment": ExchangeSegment,
+            "ExchangeInstrumentID": ExchangeInstrumentID,
+            "InstrumentType": InstrumentType,
+            "Name": Name,
+            "Series": Series,
+            "UnderlyingIndexName": UnderlyingIndexName,
+            "ContractExpiration": ContractExpiration,
+            "StrikePrice": StrikePrice,
+            "OptionType": OptionType,
+        }
+        criteria = {k: v for k, v in criteria.items() if v is not None}
+
+        if not criteria:
+            return self.__list
+
+        results = self.__list
+        for key, value in criteria.items():
+            if key == "Name":
+                results = [option for option in results if value in option.Name]
+            elif key == "ContractExpiration":
+                results = [
+                    option for option in results if option.ContractExpiration <= value
+                ]
+            else:
+                results = [
+                    option for option in results if getattr(option, key) == value
+                ]
+
+        if minimumExpiry:
+            _min_expiry = min([option.ContractExpiration for option in results])
+            results = [
+                option for option in results if option.ContractExpiration == _min_expiry
+            ]
+
+        return results

tradx/baseClass/order.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel
+
+
+class Order(BaseModel):
+    """
+    Order class representing an order in the system.
+    Attributes:
+        OrderUniqueIdentifier (str): A unique identifier for the order.
+        AppOrderID (int): The application-specific order ID.
+        OrderStatus (str): The status of the order. Defaults to an empty string.
+    Methods:
+        __init__(OrderUniqueIdentifier: str, AppOrderID: int, OrderStatus: str = ""):
+            Initializes a new instance of the Order class.
+    """
+
+    OrderUniqueIdentifier: str
+    AppOrderID: int
+    OrderStatus: str
+
+    def __init__(
+        self, OrderUniqueIdentifier: str, AppOrderID: int, OrderStatus: str = ""
+    ):
+        super().__init__(
+            OrderUniqueIdentifier=OrderUniqueIdentifier,
+            AppOrderID=AppOrderID,
+            OrderStatus=OrderStatus,
+        )

tradx/baseClass/orderEvent.py

@@ -0,0 +1,90 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from typing import Optional, Any
+from datetime import datetime, timedelta
+from decimal import Decimal
+import json
+
+def parse_decimal(value) -> Any:
+    """
+    Parses the given value and returns a decimal representation.
+    If the value is a string, it returns 0.0. Otherwise, it returns the value as is.
+    Args:
+        value: The value to be parsed. It can be of any type.
+    Returns:
+        Any: The parsed decimal value or the original value.
+    """
+
+    if isinstance(value, str):
+        return 0.0
+    return value
+def parse_datetime(value) -> Any:
+    """
+    Parses the given value into a datetime object if it is an integer.
+    If the value is an integer, it is interpreted as the number of seconds since January 1, 1980.
+    The function returns a datetime object representing that date and time.
+    If the value is not an integer, it is returned as-is.
+    Args:
+        value (Any): The value to be parsed. Expected to be an integer representing seconds since January 1, 1980, or any other type.
+    Returns:
+        Any: A datetime object if the input is an integer, otherwise the input value unchanged.
+    """
+
+    if isinstance(value, int):
+        return datetime(1980, 1, 1) + timedelta(seconds=value)
+    return value
+class OrderEvent(BaseModel):
+    
+
+    LoginID: str
+    ClientID: str = "*****"
+    AppOrderID: int
+    OrderReferenceID: Optional[str]
+    GeneratedBy: str
+    ExchangeOrderID: Optional[str]
+    OrderCategoryType: str
+    ExchangeSegment: str
+    ExchangeInstrumentID: int
+    OrderSide: str
+    OrderType: str
+    ProductType: str
+    TimeInForce: str
+    OrderPrice: Decimal
+    OrderQuantity: int
+    OrderStopPrice: Decimal
+    OrderStatus: str
+    OrderAverageTradedPrice: Annotated[Decimal, BeforeValidator(parse_decimal)]
+    LeavesQuantity: int
+    CumulativeQuantity: int
+    OrderDisclosedQuantity: int
+    OrderGeneratedDateTime: datetime
+    ExchangeTransactTime: datetime
+    LastUpdateDateTime: datetime
+    OrderExpiryDate: datetime
+    CancelRejectReason: Optional[str]
+    OrderUniqueIdentifier: str
+    OrderLegStatus: str
+    IsSpread: bool
+    BoLegDetails: int
+    BoEntryOrderId: Optional[str]
+    OrderAverageTradedPriceAPI: Annotated[Decimal, BeforeValidator(parse_decimal)]
+    OrderSideAPI: str
+    OrderGeneratedDateTimeAPI: str
+    ExchangeTransactTimeAPI: str
+    LastUpdateDateTimeAPI: str
+    OrderExpiryDateAPI: str
+    AlgoID: Optional[str]
+    AlgoCategory: int
+    MessageSynchronizeUniqueKey: str
+    MessageCode: int
+    MessageVersion: int
+    TokenID: int
+    ApplicationType: int
+    SequenceNumber: int
+    TradingSymbol: str
+
+    def __init__(self, message: str):
+        data = json.loads(message)
+        super().__init__(**data)
+
+

tradx/baseClass/position.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel
+
+
+class Position(BaseModel):
+    """
+    A class to represent a financial position.
+    Attributes:
+    -----------
+    ExchangeSegment : str
+        The segment of the exchange where the instrument is traded.
+    ExchangeInstrumentID : int
+        The unique identifier of the instrument on the exchange.
+    ProductType : str
+        The type of the financial product.
+    Quantity : int
+        The quantity of the financial instrument. Default is 0.
+    Methods:
+    --------
+    __init__(self, ExchangeSegment: str, ExchangeInstrumentID: int, ProductType: str, Quantity: int = 0):
+        Constructs all the necessary attributes for the Position object.
+    """
+
+    ExchangeSegment: str
+    ExchangeInstrumentID: int
+    ProductType: str
+    Quantity: int
+
+    def __init__(
+        self,
+        ExchangeSegment: str,
+        ExchangeInstrumentID: int,
+        ProductType: str,
+        Quantity: int = 0,
+    ):
+        assert isinstance(ExchangeSegment, str), "ExchangeSegment must be a string"
+        assert isinstance(
+            ExchangeInstrumentID, int
+        ), "ExchangeInstrumentID must be an integer"
+        assert isinstance(ProductType, str), "ProductType must be a string"
+        assert isinstance(Quantity, int), "Quantity must be an integer"
+        super().__init__(
+            ExchangeSegment=ExchangeSegment,
+            ExchangeInstrumentID=ExchangeInstrumentID,
+            ProductType=ProductType,
+            Quantity=Quantity,
+        )

tradx/baseClass/positionEvent.py

@@ -0,0 +1,84 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from decimal import Decimal
+import json
+
+
+class PositionEvent(BaseModel):
+    """
+    PositionEvent class represents a trading position event with various attributes related to trading positions.
+    Attributes:
+        LoginID (str): The login ID of the user.
+        AccountID (str): The account ID associated with the position.
+        TradingSymbol (str): The trading symbol of the instrument.
+        ExchangeSegment (str): The exchange segment where the instrument is traded.
+        ExchangeInstrumentID (int): The unique identifier for the instrument on the exchange.
+        ProductType (str): The type of product being traded.
+        Multiplier (Decimal): The multiplier for the instrument.
+        Marketlot (int): The market lot size of the instrument.
+        BuyAveragePrice (Decimal): The average price at which the instrument was bought.
+        SellAveragePrice (Decimal): The average price at which the instrument was sold.
+        LongPosition (int): The quantity of long positions.
+        ShortPosition (int): The quantity of short positions.
+        NetPosition (int): The net position (long - short).
+        BuyValue (Decimal): The total value of bought positions.
+        SellValue (Decimal): The total value of sold positions.
+        NetValue (Decimal): The net value (buy - sell).
+        UnrealizedMTM (Decimal): The unrealized mark-to-market value.
+        RealizedMTM (Decimal): The realized mark-to-market value.
+        MTM (Decimal): The total mark-to-market value.
+        BEP (Decimal): The break-even price.
+        SumOfTradedQuantityAndPriceBuy (Decimal): The sum of traded quantity and price for buy transactions.
+        SumOfTradedQuantityAndPriceSell (Decimal): The sum of traded quantity and price for sell transactions.
+        IsDayWiseNetWise (str): Indicator if the position is day-wise or net-wise.
+        StatisticsLevel (str): The level of statistics.
+        IsInterOpPosition (bool): Indicator if the position is interoperable.
+        childPositions (dict): Dictionary of child positions.
+        MessageCode (int): The message code.
+        MessageVersion (int): The version of the message.
+        TokenID (int): The token ID.
+        ApplicationType (int): The type of application.
+        SequenceNumber (int): The sequence number of the message.
+    Methods:
+        from_string(cls, message: str): Class method to create an instance of PositionEvent from a JSON string.
+    """
+
+    LoginID: str
+    AccountID: str
+    TradingSymbol: str
+    ExchangeSegment: str
+    ExchangeInstrumentID: int
+    ProductType: str
+    Multiplier: Decimal
+    Marketlot: int
+    BuyAveragePrice: Decimal
+    SellAveragePrice: Decimal
+    LongPosition: int
+    ShortPosition: int
+    NetPosition: int
+    BuyValue: Decimal
+    SellValue: Decimal
+    NetValue: Decimal
+    UnrealizedMTM: Decimal
+    RealizedMTM: Decimal
+    MTM: Decimal
+    BEP: Decimal
+    SumOfTradedQuantityAndPriceBuy: Decimal
+    SumOfTradedQuantityAndPriceSell: Decimal
+    IsDayWiseNetWise: str
+    StatisticsLevel: str
+    IsInterOpPosition: bool
+    childPositions: dict
+    MessageCode: int
+    MessageVersion: int
+    TokenID: int
+    ApplicationType: int
+    SequenceNumber: int
+
+    def __init__(self, message: str):
+        data = json.loads(message)
+        super().__init__(**data)
+
+
+