afterquote 0.1.1__py3-none-any.whl

afterquote/__init__.py

@@ -0,0 +1,8 @@
+"""
+afterquote: A lightweight package for generating synthetic after-hours
+returns between a given security and its given underlying asset.
+"""
+
+from ._security_pair import SecurityPair
+
+__all__ = ["SecurityPair"]

afterquote/_market_calendar.py

@@ -0,0 +1,102 @@
+"""Market calendar logic, to find open/close and trading days"""
+
+from datetime import datetime, timedelta
+import pandas as pd
+import pandas_market_calendars as mcal
+import pytz
+
+
+class UnsupportedExchangeError(KeyError):
+    """
+    Exception raised when a market calendar name is not found in pandas_market_calendars.
+
+    This usually occurs because yfinance exchange codes do not always match the calendar
+    names expected by pandas_market_calendars. If you encounter a missing or unrecognized
+    exchange, consider contributing to the exchange mapping in this package to improve coverage.
+    """
+
+
+class MarketCalendar:
+    """Encapsulates exchange calendar logic for various exchanges"""
+
+    # Please contribute to this list if you find more exchanges
+    # Or find a better way (please) :) - Junaid
+    _exchange_map = {
+        "NMS": "NASDAQ",
+        "NGM": "NASDAQ",
+        "BTS": "BATS",
+    }
+
+    def __init__(self):
+        pass
+
+    def is_exchange_open(
+        self,
+        yf_exchange_name,
+        timestamp: pd.Timestamp = pd.Timestamp(datetime.now(pytz.utc)),
+    ) -> bool:
+        """Checks if an exchange is trading at a given timestamp"""
+
+        cal = self.__get_calendar(yf_exchange_name)
+        schedule = self.__get_schedule(cal)
+
+        converted_timestamp = timestamp.tz_convert(cal.tz)
+
+        try:
+            return cal.open_at_time(schedule, converted_timestamp)
+        except (ValueError, IndexError):
+            return False
+
+    def get_closing_time(self, yf_exchange_name) -> pd.Timestamp:
+        """Returns last closing time of the exchange"""
+
+        exchange = self.__get_calendar(yf_exchange_name)
+        schedule = exchange.schedule(
+            start_date=datetime.now().today() - timedelta(days=5),
+            end_date=datetime.now().today(),
+        )
+        recent_closes = schedule[-2:]["market_close"].tolist()
+        recent_closes.reverse()
+
+        for close in recent_closes:
+            if close < datetime.now(pytz.utc):
+                return close
+
+        raise ValueError("Cannot find the last market close")
+
+    def get_exchange_tz(self, yf_exchange_name) -> pytz.tzinfo.BaseTzInfo:
+        """Returns the timezone for a given exchange"""
+
+        cal = self.__get_calendar(yf_exchange_name)
+        return cal.tz
+
+    def __get_calendar(self, yf_exchange_name) -> mcal.MarketCalendar:
+        """Retrieves a pandas_market_calendars calendar for the given exchange name"""
+
+        try:
+            return mcal.get_calendar(
+                self._exchange_map.get(yf_exchange_name, yf_exchange_name)
+            )
+        except RuntimeError as e:
+            raise UnsupportedExchangeError(
+                f"Could not retrieve calendar for exchange '{yf_exchange_name}'. "
+                f"Please consider contributing to this file to add support - Junaid"
+            ) from e
+
+    def __get_schedule(
+        self,
+        exchange_cal: mcal.MarketCalendar,
+        start=datetime.now().today(),
+        end=datetime.now().today(),
+    ) -> pd.DataFrame:
+        """Retrieves a schedule for a pandas market calendar"""
+        try:
+            return exchange_cal.schedule(
+                start_date=start, end_date=end, start="pre", end="post"
+            )
+        # Handle exchanges with no extended hours
+        except ValueError:
+            return exchange_cal.schedule(
+                start_date=start,
+                end_date=end,
+            )

afterquote/_security_pair.py

@@ -0,0 +1,88 @@
+"""Providing a quote for a security from its underlying asset"""
+
+import pandas as pd
+from ._yfinance_wrapper import YFinanceSecurity
+from ._market_calendar import MarketCalendar
+
+
+class SecurityPair:
+    """Class holding the leveraged etf and its underlying security"""
+
+    def __init__(self, base, underlying):
+        self.base_yf = YFinanceSecurity(base)
+        self.underlying_yf = YFinanceSecurity(underlying)
+
+        if not self.is_valid_pair():
+            raise ValueError(
+                f"Invalid security pair: {base}, {underlying}",
+                "Please use yfinance tickers",
+            )
+
+        self.calendar = MarketCalendar()
+
+    def is_valid_pair(self) -> bool:
+        """Returns if both of the tickers provided are found by yfinance"""
+
+        return self.underlying_yf.is_real_security() and self.base_yf.is_real_security()
+
+    def is_pair_fully_live(self) -> bool:
+        """
+        Returns if both of the securities are currently trading,
+        meaning no synthetic return is needed
+        """
+
+        return self.calendar.is_exchange_open(
+            self.base_yf.get_exchange()
+        ) and self.calendar.is_exchange_open(self.underlying_yf.get_exchange())
+
+    def quote(self) -> pd.DataFrame:
+        """Returns a df with the latest possible quote for the underlying security"""
+
+        if self.is_pair_fully_live():
+            raise RuntimeError(
+                "Cannot compute synthetic return — both securities are currently trading."
+            )
+
+        # Get the last closing time of the base security
+        close_time = self.calendar.get_closing_time(self.base_yf.get_exchange())
+        close_price = self.base_yf.get_price_at(close_time)
+        # Convert that to the timezone of the underlying security
+        target_timezone = self.calendar.get_exchange_tz(
+            self.underlying_yf.get_exchange()
+        )
+        # The close of the base security is our start for the underlying security
+        start_time = close_time.astimezone(target_timezone)
+
+        # Get the start price of the underlying security
+        start_price = self.underlying_yf.get_price_at(start_time)
+        # Get the current price of the underlying security
+        live_data = self.underlying_yf.yf_ticker.history(
+            period="5d", interval="1m", prepost=True
+        )
+        latest_price = live_data["Close"].iloc[-1]
+        latest_time = live_data.index[-1]
+
+        # Calculate the percentage return of the underlying security
+        change = latest_price - start_price
+        percent_return = (change / start_price) * 100
+
+        leverage_factor = self.base_yf.get_leverage()
+        leveraged_return = percent_return * leverage_factor
+
+        # Calculate the quote price based on the leveraged return
+        quote_price = close_price * (1 + (leveraged_return / 100))
+
+        return pd.DataFrame(
+            [
+                {
+                    "base_security": self.base_yf.ticker,
+                    "underlying_security": self.underlying_yf.ticker,
+                    "leverage": leverage_factor,
+                    "base_close_time": start_time,
+                    "base_close_price": close_price,
+                    "adj_percent_return": leveraged_return,
+                    "quote_time": latest_time,
+                    "quote_price": quote_price,
+                }
+            ]
+        )

afterquote/_yfinance_wrapper.py

@@ -0,0 +1,78 @@
+"""Used for querying information and pricing for securities"""
+
+import re
+from datetime import timedelta
+import pandas as pd
+import pytz
+import yfinance as yf
+
+
+class YFinanceSecurity:
+    """Wrapper for yfinance objects"""
+
+    def __init__(self, ticker):
+        self.ticker = ticker
+        self.yf_ticker = yf.Ticker(ticker)
+
+    def is_real_security(self) -> bool:
+        """Returns whether yfinance found the ticker"""
+
+        try:
+            self.yf_ticker.info.get("longName")
+            return True
+        except AttributeError:
+            return False
+
+    def get_leverage(self) -> int:
+        """Returns the leverage for a security"""
+
+        info = self.yf_ticker.info
+        long_name = info.get("longName", "Error finding long name")
+        match = re.search(r"(-?\d+x)", long_name)
+        if match:
+            leverage = match.group(0).replace("x", "")
+            if (
+                "short" in long_name.lower() or "inverse" in long_name.lower()
+            ) and leverage[0] != "-":
+                leverage = f"-{leverage}"
+            return int(leverage)
+
+        return 1
+
+    def get_timezone(self) -> pytz.tzinfo.BaseTzInfo:
+        """Returns a pytz timezone for a security"""
+
+        info = self.yf_ticker.info
+        timezone_name = info.get("timeZoneFullName")
+        if not timezone_name:
+            raise ValueError(f"Timezone not found for {self.ticker}")
+        return pytz.timezone(timezone_name)
+
+    def get_exchange(self) -> str:
+        """Returns the exchange for a security"""
+
+        info = self.yf_ticker.info
+        exchange_name = info.get("exchange")
+        if not exchange_name:
+            raise ValueError(f"Exchange not found for {self.ticker}")
+        return exchange_name
+
+    def get_price_at(self, timestamp: pd.Timestamp) -> float:
+        """Fetches the price closest to the given timestamp using 1-minute interval data"""
+
+        data = self.yf_ticker.history(
+            start=timestamp - timedelta(minutes=5),
+            end=timestamp + timedelta(minutes=5),
+            interval="1m",
+            prepost=True,
+        )
+        if data.empty:
+            raise ValueError(
+                f"No pricing data for {self.ticker} found around {timestamp.isoformat()}"
+            )
+        if timestamp in data.index:
+            price = data.loc[timestamp].Open
+        else:
+            price = data.iloc[0].Open
+
+        return price

afterquote-0.1.1.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: afterquote
+Version: 0.1.1
+Summary: Synthetic after-hours quote generator
+Author-email: Mohammad Junaid <mohammadjunaiduk@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: yfinance
+Requires-Dist: pandas
+Requires-Dist: pytz
+Requires-Dist: pandas_market_calendars
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Dynamic: license-file
+
+# afterquote
+
+**Synthetic after-hours quote generator based on an asset and its correlated underlying.**
+
+---
+
+## 📦 What is this?
+
+`afterquote` lets you estimate synthetic prices for a financial security based on the real-time performance of a given correlated underlying asset — useful when one market is closed and the other is still trading.
+
+---
+
+## 🚀 Installation
+
+### From PyPI (planned):
+```bash
+pip install afterquote
+```
+
+### Locally:
+
+```bash
+pip install -e .
+```
+
+## 🧪 Usage
+
+```python
+from afterquote import SecurityPair
+
+pair = SecurityPair("MAG5.L", "MAGS")
+quote_df = pair.quote()
+print(quote_df)
+```
+
+## 📘 Example Output
+
+```text
+  base_security underlying_security  leverage           base_close_time  base_close_price  adj_percent_return                 quote_time   quote_price
+0        MAG5.L                MAGS         5 2025-05-09 11:30:00-04:00             792.0           -1.044288  2025-05-09 19:59:00-04:00    783.729235
+```
+
+## 🤝 Contributing
+
+Feel free to open issues or submit pull requests if you find bugs or want to improve the package - Junaid :)
+
+
+## 📄 License
+
+MIT License. See the [LICENSE](./LICENSE) file for full details.

afterquote-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+afterquote/__init__.py,sha256=UNwVeYKd1pXTSOfX9JA3LQpa7IP5EMZO6fgo9xYO4eA,222
+afterquote/_market_calendar.py,sha256=pEBMJ8zbN_pll9rT3ZwAg3cNW3O_NDVqO7KlTH6cYbI,3545
+afterquote/_security_pair.py,sha256=oliTmSe3QxkG10yhUaxqBmIDokyJ7TFbYgxF1UjdGyE,3467
+afterquote/_yfinance_wrapper.py,sha256=jHwtrqQyROGnfjvHCDMgoPdVWIE2_vUg4AMYmwynkT8,2495
+afterquote-0.1.1.dist-info/licenses/LICENSE,sha256=pZy9gOa0pJIhpdbZ_i5fthJHzDU_7cXV4YtXwb1c--s,1084
+afterquote-0.1.1.dist-info/METADATA,sha256=BJmApJITdgsrJU5y35RNEA9F2jy2hwIn56h7zg0BcY8,1742
+afterquote-0.1.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+afterquote-0.1.1.dist-info/top_level.txt,sha256=3WDLaV4J6s2NvRiavlyKcCFV_U3ITVMMrmhAJluBiPU,11
+afterquote-0.1.1.dist-info/RECORD,,

afterquote-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

afterquote-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Junaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

afterquote-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+afterquote