tradx 0.1.0__py3-none-any.whl

tradx/baseClass/index.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel
+
+class Index(BaseModel):
+    """
+    A class used to represent an Index.
+    Attributes
+    ----------
+    Name : str
+        The name of the index.
+    ExchangeSegment : int
+        The segment of the exchange.
+    ExchangeInstrumentID : int
+        The instrument ID of the exchange.
+    Methods
+    -------
+    __init__(self, Name: str, ExchangeSegment: int, ExchangeInstrumentID: int)
+        Constructs all the necessary attributes for the Index object.
+    """
+
+    Name: str
+    ExchangeSegment: int
+    ExchangeInstrumentID: int
+    def __init__(self, Name: str, ExchangeSegment: int, ExchangeInstrumentID: int):
+        super().__init__(Name=Name, ExchangeSegment=ExchangeSegment, ExchangeInstrumentID=ExchangeInstrumentID)

tradx/baseClass/instrumentPropertyChangeData.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+from typing import Any
+import json
+from enum import Enum
+
+
+class InstrumentPropertyChangeData(BaseModel): 
+    """
+    yet to be implemented
+    """
+    ...

tradx/baseClass/ltpData.py

@@ -0,0 +1,89 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+from typing import Any, Dict
+import json
+from enum import Enum
+
+
+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 ExchangeMarketType(Enum):
+    """
+    Enum class representing different types of exchange market statuses.
+    Attributes:
+        Normal (int): Represents a normal market type.
+        OddLot (int): Represents an odd lot market type.
+        Spot (int): Represents a spot market type.
+        Auction (int): Represents an auction market type.
+        CallAuction1 (int): Represents the first call auction market type.
+        CallAuction2 (int): Represents the second call auction market type.
+    """
+
+    Normal = 1
+    OddLot = 2
+    Spot = 3
+    Auction = 4
+    CallAuction1 = 5
+    CallAuction2 = 6
+
+
+class LtpData(BaseModel):
+    """
+    LtpData model representing the Last Traded Price data.
+    Attributes:
+        MessageCode (int): The message code.
+        MessageVersion (int): The version of the message.
+        ApplicationType (int): The type of application.
+        TokenID (int): The token ID.
+        ExchangeSegment (int): The exchange segment.
+        ExchangeInstrumentID (int): The exchange instrument ID.
+        BookType (int): The type of book.
+        XMarketType (ExchangeMarketType): The market type.
+        LastTradedPrice (Decimal): The last traded price.
+        LastTradedQunatity (int): The last traded quantity.
+        LastUpdateTime (datetime): The last update time, parsed from a string.
+    Methods:
+        from_string(cls, message: str): Class method to create an instance of LtpData from a JSON string.
+    """
+
+    MessageCode: int
+    MessageVersion: int
+    ApplicationType: int
+    TokenID: int
+    ExchangeSegment: int
+    ExchangeInstrumentID: int
+    BookType: int
+    XMarketType: ExchangeMarketType
+    LastTradedPrice: Decimal
+    LastTradedQunatity: int
+    LastUpdateTime: Annotated[datetime, BeforeValidator(parse_datetime)]
+
+    class Config:
+        use_enum_values = True
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+    
+            data = json.loads(input_data)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for LtpData")

tradx/baseClass/ltpPartialData.py

@@ -0,0 +1,108 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+from typing import Any, Dict
+import json
+from enum import Enum
+
+
+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 ExchangeMarketType(Enum):
+    """
+    Enum class representing different types of exchange market statuses.
+    Attributes:
+        Normal (int): Represents a normal market type.
+        OddLot (int): Represents an odd lot market type.
+        Spot (int): Represents a spot market type.
+        Auction (int): Represents an auction market type.
+        CallAuction1 (int): Represents the first call auction market type.
+        CallAuction2 (int): Represents the second call auction market type.
+    """
+
+    Normal = 1
+    OddLot = 2
+    Spot = 3
+    Auction = 4
+    CallAuction1 = 5
+    CallAuction2 = 6
+
+
+class LtpPartialData(BaseModel):
+    """
+    LtpPartialData is a model representing partial data for the last traded price (LTP) of an instrument.
+    Attributes:
+        ExchangeSegment (int): The exchange segment identifier.
+        ExchangeInstrumentID (int): The exchange instrument identifier.
+        BookType (int): The book type identifier.
+        MarketType (ExchangeMarketType): The market type.
+        LastTradedPrice (Decimal): The last traded price of the instrument.
+        LastTradedQunatity (int): The last traded quantity of the instrument.
+        LastUpdateTime (datetime): The last update time of the data.
+    Methods:
+        from_string(cls, message: str): Parses a string message to create an instance of LtpPartialData.
+            Args:
+                message (str): The input string containing key-value pairs separated by commas.
+            Returns:
+                LtpPartialData: An instance of LtpPartialData populated with the parsed data.
+    """
+
+    ExchangeSegment: int
+    ExchangeInstrumentID: int
+    BookType: int
+    MarketType: ExchangeMarketType
+    LastTradedPrice: Decimal
+    LastTradedQunatity: int
+    LastUpdateTime: Annotated[datetime, BeforeValidator(parse_datetime)]
+
+    class Config:
+        use_enum_values = True
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+  
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+        
+            # Split the message by commas to get individual key-value pairs
+            key_value_pairs = input_data.split(",")
+
+            # Initialize an empty dictionary to store the parsed data
+            data = {}
+
+            # Iterate over each key-value pair
+            for pair in key_value_pairs:
+                key, value = pair.split(":")
+                if key == "t":
+                    exchange_segment, instrument_id = map(int, value.split("_"))
+                    data["ExchangeSegment"] = exchange_segment
+                    data["ExchangeInstrumentID"] = instrument_id
+                elif key == "ltp":
+                    data["LastTradedPrice"] = Decimal(value)
+                elif key == "ltq":
+                    data["LastTradedQunatity"] = int(value)
+                elif key == "lut":
+                    data["LastUpdateTime"] = int(value)
+                elif key == "bt":
+                    data["BookType"] = int(value)
+                elif key == "mt":
+                    data["MarketType"] = int(value)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for LtpPartialData")

tradx/baseClass/marketDepthData.py

@@ -0,0 +1,126 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+from typing import Any, Dict
+import json
+
+
+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 BidAskInfo(BaseModel):
+    """
+    BidAskInfo is a data model representing the bid and ask information in a market depth context.
+    Attributes:
+        Size (int): The size of the bid or ask.
+        Price (Decimal): The price of the bid or ask.
+        TotalOrders (int): The total number of orders at this bid or ask price.
+        BuyBackMarketMaker (int): Indicator if the market maker is buying back.
+    """
+
+    Size: int
+    Price: Decimal
+    TotalOrders: int
+    BuyBackMarketMaker: int
+
+
+class TouchlineInfo(BaseModel):
+    """
+    TouchlineInfo represents the market depth data for a trading instrument.
+    Attributes:
+        BidInfo (BidAskInfo): Information about the bid.
+        AskInfo (BidAskInfo): Information about the ask.
+        LastTradedPrice (Decimal): The last traded price of the instrument.
+        LastTradedQunatity (int): The quantity of the last trade.
+        TotalBuyQuantity (int): The total quantity of buy orders.
+        TotalSellQuantity (int): The total quantity of sell orders.
+        TotalTradedQuantity (int): The total quantity of traded orders.
+        AverageTradedPrice (Decimal): The average price of traded orders.
+        LastTradedTime (datetime): The time of the last trade.
+        LastUpdateTime (datetime): The time of the last update.
+        PercentChange (Decimal): The percentage change in price.
+        Open (Decimal): The opening price.
+        High (Decimal): The highest price.
+        Low (Decimal): The lowest price.
+        Close (Decimal): The closing price.
+        TotalValueTraded (int): The total value of traded orders.
+        BuyBackTotalBuy (int): The total quantity of buy-back orders.
+        BuyBackTotalSell (int): The total quantity of sell-back orders.
+    """
+
+    BidInfo: BidAskInfo
+    AskInfo: BidAskInfo
+    LastTradedPrice: Decimal
+    LastTradedQunatity: int
+    TotalBuyQuantity: int
+    TotalSellQuantity: int
+    TotalTradedQuantity: int
+    AverageTradedPrice: Decimal
+    LastTradedTime: Annotated[datetime, BeforeValidator(parse_datetime)]
+    LastUpdateTime: Annotated[datetime, BeforeValidator(parse_datetime)]
+    PercentChange: Decimal
+    Open: Decimal
+    High: Decimal
+    Low: Decimal
+    Close: Decimal
+    TotalValueTraded: int
+    BuyBackTotalBuy: int
+    BuyBackTotalSell: int
+
+
+class MarketDepthData(BaseModel):
+    """
+    MarketDepthData represents the market depth information for a specific instrument.
+    Attributes:
+        MessageCode (int): The code representing the type of message.
+        MessageVersion (int): The version of the message format.
+        ApplicationType (int): The type of application sending the message.
+        TokenID (int): The unique identifier for the token.
+        ExchangeSegment (int): The segment of the exchange.
+        ExchangeInstrumentID (int): The unique identifier for the instrument on the exchange.
+        ExchangeTimeStamp (datetime): The timestamp of the data from the exchange.
+        Bids (list[BidAskInfo]): A list of bid information.
+        Asks (list[BidAskInfo]): A list of ask information.
+        Touchline (TouchlineInfo): The touchline information.
+        BookType (int): The type of order book.
+        XMarketType (int): The type of market.
+        SequenceNumber (int): The sequence number of the message.
+    """
+
+    MessageCode: int
+    MessageVersion: int
+    ApplicationType: int
+    TokenID: int
+    ExchangeSegment: int
+    ExchangeInstrumentID: int
+    ExchangeTimeStamp: Annotated[datetime, BeforeValidator(parse_datetime)]
+    Bids: list[BidAskInfo]
+    Asks: list[BidAskInfo]
+    Touchline: TouchlineInfo
+    BookType: int
+    XMarketType: int
+    SequenceNumber: int
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+            data = json.loads(input_data)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for MarketDepthData")

tradx/baseClass/marketStatusData.py

@@ -0,0 +1,110 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+import json
+from typing import Any, Dict
+from enum import Enum
+
+
+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 ExchangeTradingSession(Enum):
+    """
+    Enum class representing different stages of an exchange trading session.
+    Attributes:
+        PreOpenStart (int): Represents the start of the pre-open session.
+        PreOpenEnd (int): Represents the end of the pre-open session.
+        NormalStart (int): Represents the start of the normal trading session.
+        NormalEnd (int): Represents the end of the normal trading session.
+        PreClosingStart (int): Represents the start of the pre-closing session.
+        PreClosingEnd (int): Represents the end of the pre-closing session.
+    """
+
+    PreOpenStart = 0
+    PreOpenEnd = 1
+    NormalStart = 2
+    NormalEnd = 4
+    PreClosingStart = 8
+    PreClosingEnd = 16
+
+
+class ExchangeMarketType(Enum):
+    """
+    Enum class representing different types of exchange market statuses.
+    Attributes:
+        Normal (int): Represents a normal market type.
+        OddLot (int): Represents an odd lot market type.
+        Spot (int): Represents a spot market type.
+        Auction (int): Represents an auction market type.
+        CallAuction1 (int): Represents the first call auction market type.
+        CallAuction2 (int): Represents the second call auction market type.
+    """
+
+    Normal = 1
+    OddLot = 2
+    Spot = 3
+    Auction = 4
+    CallAuction1 = 5
+    CallAuction2 = 6
+
+
+class MarketStatusData(BaseModel):
+    """
+    MarketStatusData is a data model representing the status of a market.
+    Attributes:
+        ApplicationType (int): The type of application.
+        ExchangeInstrumentID (int): The ID of the exchange instrument.
+        ExchangeSegment (int): The segment of the exchange.
+        ExchangeTimeStamp (datetime): The timestamp of the exchange, validated and parsed.
+        maketType (ExchangeMarketType): The type of market.
+        message (str): The message content.
+        MessageCode (int): The code of the message.
+        MessageVersion (int): The version of the message.
+        SequenceNumber (int): The sequence number.
+        TokenID (int): The token ID.
+        tradingSession (ExchangeTradingSession): The trading session.
+    Methods:
+        from_string(cls, message: str): Class method to create an instance of MarketStatusData from a JSON string.
+    """
+
+    ApplicationType: int
+    ExchangeInstrumentID: int
+    ExchangeSegment: int
+    ExchangeTimeStamp: Annotated[datetime, BeforeValidator(parse_datetime)]
+    maketType: ExchangeMarketType
+    message: str
+    MessageCode: int
+    MessageVersion: int
+    SequenceNumber: int
+    TokenID: int
+    tradingSession: ExchangeTradingSession
+
+    class Config:
+        use_enum_values = True
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+
+            data = json.loads(input_data)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for MarketStatusData")

tradx/baseClass/openInterestData.py

@@ -0,0 +1,84 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+import json
+from typing import Any, Dict
+from enum import Enum
+
+
+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 ExchangeMarketType(Enum):
+    """
+    Enum class representing different types of exchange market statuses.
+    Attributes:
+        Normal (int): Represents a normal market type.
+        OddLot (int): Represents an odd lot market type.
+        Spot (int): Represents a spot market type.
+        Auction (int): Represents an auction market type.
+        CallAuction1 (int): Represents the first call auction market type.
+        CallAuction2 (int): Represents the second call auction market type.
+    """
+
+    Normal = 1
+    OddLot = 2
+    Spot = 3
+    Auction = 4
+    CallAuction1 = 5
+    CallAuction2 = 6
+
+
+class OpenInterestData(BaseModel):
+    """
+    OpenInterestData model representing the structure of open interest data.
+    Attributes:
+        MessageCode (int): The message code.
+        MessageVersion (int): The version of the message.
+        ApplicationType (int): The type of application.
+        TokenID (int): The token ID.
+        ExchangeSegment (int): The exchange segment.
+        ExchangeInstrumentID (int): The exchange instrument ID.
+        ExchangeTimeStamp (datetime): The timestamp of the exchange, validated and parsed.
+        XTSMarketType (ExchangeMarketType): The market type of the exchange.
+        OpenInterest (int): The open interest value.
+    Methods:
+        from_string(cls, message: str): Class method to create an instance of OpenInterestData from a JSON string.
+    """
+
+    MessageCode: int
+    MessageVersion: int
+    ApplicationType: int
+    TokenID: int
+    ExchangeSegment: int
+    ExchangeInstrumentID: int
+    ExchangeTimeStamp: Annotated[datetime, BeforeValidator(parse_datetime)]
+    XTSMarketType: ExchangeMarketType
+    OpenInterest: int
+
+    class Config:
+        use_enum_values = True
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+            data = json.loads(input_data)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for OpenInterestData")

tradx/baseClass/openInterestPartialData.py

@@ -0,0 +1,47 @@
+from pydantic import BaseModel, BeforeValidator
+from typing_extensions import Annotated
+from decimal import Decimal
+from datetime import datetime, timedelta
+import json
+from typing import Any, Dict
+
+
+class OpenInterestPartialData(BaseModel):
+    """
+    A class to represent partial data of open interest.
+    Attributes:
+    -----------
+    ExchangeSegment : int
+        The segment of the exchange.
+    ExchangeInstrumentID : int
+        The instrument ID of the exchange.
+    OpenInterest : int
+        The open interest value.
+    Methods:
+    --------
+    from_string(cls, message: str):
+        Parses a string message to create an instance of OpenInterestPartialData.
+        The message should be in the format "t:exchange_segment_instrument_id,o:open_interest".
+    """
+
+    ExchangeSegment: int
+    ExchangeInstrumentID: int
+    OpenInterest: int
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+            parts = input_data.split(",")
+            data = {}
+            for part in parts:
+                key, value = part.split(":")
+                if key == "t":
+                    exchange_segment, instrument_id = value.split("_")
+                    data["ExchangeSegment"] = int(exchange_segment)
+                    data["ExchangeInstrumentID"] = int(instrument_id)
+                elif key == "o":
+                    data["OpenInterest"] = int(value)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for OpenInterestPartialData")