quantmod 0.1.2__tar.gz → 0.1.3__tar.gz

{quantmod-0.1.2 → quantmod-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: quantmod
-Version: 0.1.2
+Version: 0.1.3
 Summary: Quantmod Python Package
 Home-page: https://kannansingaravelu.com/
 Author: Kannan Singaravelu
@@ -28,9 +28,10 @@ Requires-Dist: plotly>=6.1.2
 Requires-Dist: pydantic>=2.8.2
 Requires-Dist: scipy>=1.13.1
 Requires-Dist: sqlalchemy>=2.0.38
+Requires-Dist: supabase>=2.27.2
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: urllib3==1.26.15
-Requires-Dist: yfinance==0.2.58
+Requires-Dist: yfinance>=1.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

quantmod-0.1.3/quantmod/db/__init__.py

@@ -0,0 +1,23 @@
+# Quantmod Python Package
+# https://kannansingaravelu.com/
+
+# Copyright 2024 Kannan Singaravelu
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from .database import QuantmodDB
+
+__all__ = [
+    "QuantmodDB",
+]

quantmod-0.1.3/quantmod/db/database.py

@@ -0,0 +1,514 @@
+from datetime import datetime
+import pandas as pd
+from supabase import create_client, Client
+from typing import Union, List, Optional, Dict
+from quantmod.markets import getData
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+# Suppress verbose logging from dependencies
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+
+
+
+class QuantmodDB:
+    """
+    QuantmodDB
+    ----------------
+    Python SDK for registering instruments, ingesting OHLCV price data,
+    and retrieving historical market data from Supabase.
+
+    Assumptions:
+    - Supabase tables `instruments` and `prices` already exist
+    - UNIQUE constraint on instruments.symbol
+    - UNIQUE constraint on prices (instrument_id, date)
+    - RLS disabled OR service-role key is used
+    - getData() returns DataFrame indexed by datetime with
+      Open, High, Low, Close, Volume columns
+    """
+
+    def __init__(self, supabase_url: str, supabase_key: str):
+        if not supabase_url or not supabase_key:
+            raise ValueError("Supabase URL or Key missing")
+
+        self.supabase: Client = create_client(supabase_url, supabase_key)
+        self._instrument_cache: Dict[str, int] = {}
+
+    # ------------------------------------------------------------------
+    # Instrument Registration
+    # ------------------------------------------------------------------
+
+    def register(self, instruments: Union[dict, List[dict]]) -> List[int]:
+        """
+        Register one or multiple instruments with metadata.
+        Idempotent: existing symbols are updated with new metadata.
+
+        Parameters
+        ----------
+        instruments : dict | list[dict]
+            Instrument(s) to register. Each dict must contain 'symbol'.
+            Optional keys: name, exchange, asset_class, instrument_type
+
+        Returns
+        -------
+        list[int]
+            Instrument IDs (existing or newly created)
+
+        Raises
+        ------
+        ValueError
+            If instrument dict is missing 'symbol' key
+        """
+        if isinstance(instruments, dict):
+            instruments = [instruments]
+
+        if not instruments:
+            return []
+
+        # Validate all instruments have symbols
+        for inst in instruments:
+            if "symbol" not in inst:
+                raise ValueError("Each instrument must have a 'symbol' key")
+
+        symbols = [inst["symbol"] for inst in instruments]
+
+        # Batch fetch existing instruments
+        try:
+            resp = (
+                self.supabase.table("instruments")
+                .select("id, symbol")
+                .in_("symbol", symbols)
+                .execute()
+            )
+            
+            existing = {row["symbol"]: row["id"] for row in resp.data} if resp.data else {}
+        except Exception as e:
+            logger.error(f"Failed to fetch existing instruments: {e}")
+            raise
+
+        ids: List[int] = []
+        to_insert: List[dict] = []
+        to_update: List[dict] = []
+
+        for inst in instruments:
+            symbol = inst["symbol"]
+            
+            payload = {
+                "symbol": symbol,
+                "name": inst.get("name", symbol),
+                "exchange": inst.get("exchange"),
+                "asset_class": inst.get("asset_class"),
+                "instrument_type": inst.get("instrument_type"),
+            }
+
+            if symbol in existing:
+                # Update existing instrument
+                inst_id = existing[symbol]
+                ids.append(inst_id)
+                to_update.append({"id": inst_id, **payload})
+                # Update cache
+                self._instrument_cache[symbol] = inst_id
+            else:
+                # New instrument
+                to_insert.append(payload)
+
+        # Batch insert new instruments
+        if to_insert:
+            try:
+                resp = self.supabase.table("instruments").insert(to_insert).execute()
+                for row in resp.data:
+                    ids.append(row["id"])
+                    self._instrument_cache[row["symbol"]] = row["id"]
+                logger.info(f"Registered {len(to_insert)} new instruments")
+            except Exception as e:
+                logger.error(f"Failed to insert instruments: {e}")
+                raise
+
+        # Batch update existing instruments
+        if to_update:
+            try:
+                for update in to_update:
+                    self.supabase.table("instruments").update(update).eq("id", update["id"]).execute()
+                logger.info(f"Updated {len(to_update)} existing instruments")
+            except Exception as e:
+                logger.error(f"Failed to update instruments: {e}")
+                raise
+
+        return ids
+
+    def get_instrument_id(self, symbol: str) -> Optional[int]:
+        """
+        Get instrument ID for a symbol.
+
+        Parameters
+        ----------
+        symbol : str
+            Instrument symbol
+
+        Returns
+        -------
+        int | None
+            Instrument ID if found, None otherwise
+        """
+        # Check cache first
+        if symbol in self._instrument_cache:
+            return self._instrument_cache[symbol]
+
+        # Query database
+        try:
+            resp = (
+                self.supabase.table("instruments")
+                .select("id")
+                .eq("symbol", symbol)
+                .maybe_single()
+                .execute()
+            )
+
+            if resp.data:
+                inst_id = resp.data["id"]
+                self._instrument_cache[symbol] = inst_id
+                return inst_id
+            return None
+        except Exception as e:
+            logger.error(f"Failed to fetch instrument ID for {symbol}: {e}")
+            raise
+
+    def list_instruments(
+        self, 
+        symbols: Optional[Union[str, List[str]]] = None,
+        exchange: Optional[str] = None,
+        asset_class: Optional[str] = None
+    ) -> pd.DataFrame:
+        """
+        List registered instruments with optional filters.
+
+        Parameters
+        ----------
+        symbols : str | list[str], optional
+            Filter by specific symbol(s)
+        exchange : str, optional
+            Filter by exchange
+        asset_class : str, optional
+            Filter by asset class
+
+        Returns
+        -------
+        DataFrame
+            Registered instruments with metadata
+        """
+        try:
+            query = self.supabase.table("instruments").select("*")
+
+            if symbols is not None:
+                if isinstance(symbols, str):
+                    symbols = [symbols]
+                query = query.in_("symbol", symbols)
+            if exchange:
+                query = query.eq("exchange", exchange)
+            if asset_class:
+                query = query.eq("asset_class", asset_class)
+
+            resp = query.order("symbol").execute()
+
+            if not resp.data:
+                return pd.DataFrame()
+
+            return pd.DataFrame(resp.data)
+        except Exception as e:
+            logger.error(f"Failed to list instruments: {e}")
+            raise
+
+    # ------------------------------------------------------------------
+    # Historical Data Ingestion
+    # ------------------------------------------------------------------
+
+    def load_history(
+        self,
+        symbols: Union[str, List[str]],
+        start_date: str,
+        end_date: Optional[str] = None,
+    ) -> Dict[str, int]:
+        """
+        Load historical OHLCV data for one or multiple symbols.
+        
+        All symbols MUST be registered before loading data.
+        Use register() first to add instruments with metadata.
+
+        Parameters
+        ----------
+        symbols : str | list[str]
+            Symbol(s) to load data for (must be pre-registered)
+        start_date : str
+            Start date in YYYY-MM-DD format
+        end_date : str, optional
+            End date in YYYY-MM-DD format (defaults to today)
+
+        Returns
+        -------
+        dict
+            {symbol: num_records_loaded}
+
+        Raises
+        ------
+        ValueError
+            If any symbol is not registered
+        """
+        if end_date is None:
+            end_date = datetime.now().strftime("%Y-%m-%d")
+
+        # Normalize to list
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        # Validate all symbols are registered
+        symbol_to_id: Dict[str, int] = {}
+        missing_symbols: List[str] = []
+
+        for symbol in symbols:
+            inst_id = self.get_instrument_id(symbol)
+            if inst_id is None:
+                missing_symbols.append(symbol)
+            else:
+                symbol_to_id[symbol] = inst_id
+
+        if missing_symbols:
+            raise ValueError(
+                f"Instruments not registered: {missing_symbols}. "
+                f"Use register() to add them first."
+            )
+
+        # Load data for each symbol
+        results: Dict[str, int] = {}
+
+        for symbol, inst_id in symbol_to_id.items():
+            try:
+                # Fetch market data
+                df = getData(symbol, start_date=start_date, end_date=end_date)
+
+                if df.empty:
+                    logger.warning(f"No data available for {symbol}")
+                    results[symbol] = 0
+                    continue
+
+                # Prepare rows with NaN handling
+                rows = []
+                for idx, row in df.iterrows():
+                    try:
+                        rows.append({
+                            "instrument_id": inst_id,
+                            "date": idx.strftime("%Y-%m-%d"),
+                            "open": float(row["Open"]) if pd.notna(row["Open"]) else None,
+                            "high": float(row["High"]) if pd.notna(row["High"]) else None,
+                            "low": float(row["Low"]) if pd.notna(row["Low"]) else None,
+                            "close": float(row["Close"]) if pd.notna(row["Close"]) else None,
+                            "volume": int(row["Volume"]) if pd.notna(row["Volume"]) else 0,
+                        })
+                    except (ValueError, KeyError) as e:
+                        logger.warning(f"Skipping invalid row for {symbol} at {idx}: {e}")
+                        continue
+
+                if not rows:
+                    logger.warning(f"No valid data rows for {symbol}")
+                    results[symbol] = 0
+                    continue
+
+                # Upsert OHLCV data
+                self.supabase.table("prices").upsert(
+                    rows, on_conflict="instrument_id,date"
+                ).execute()
+
+                results[symbol] = len(rows)
+                logger.info(f"Loaded {len(rows)} records for {symbol}")
+
+            except Exception as e:
+                logger.error(f"Failed to load data for {symbol}: {e}")
+                results[symbol] = -1  # Indicate failure
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Data Retrieval
+    # ------------------------------------------------------------------
+
+    def get_prices(
+        self,
+        symbols: Optional[Union[str, List[str]]] = None,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> pd.DataFrame:
+        """
+        Retrieve OHLCV data in long format.
+
+        Parameters
+        ----------
+        symbols : str | list[str], optional
+            Filter by symbol(s). If None, returns all.
+        start_date : str, optional
+            Start date filter (YYYY-MM-DD)
+        end_date : str, optional
+            End date filter (YYYY-MM-DD)
+        limit : int, optional
+            Maximum number of records to return
+
+        Returns
+        -------
+        DataFrame
+            Columns: date, open, high, low, close, volume, symbol
+            Sorted by date ascending
+        """
+        try:
+            query = self.supabase.table("prices").select(
+                "date, open, high, low, close, volume, instruments!inner(symbol)"
+            )
+
+            if symbols is not None:
+                if isinstance(symbols, str):
+                    symbols = [symbols]
+                query = query.in_("instruments.symbol", symbols)
+
+            if start_date:
+                query = query.gte("date", start_date)
+            if end_date:
+                query = query.lte("date", end_date)
+
+            query = query.order("date", desc=False)
+
+            if limit:
+                query = query.limit(limit)
+
+            resp = query.execute()
+
+            if not resp.data:
+                return pd.DataFrame(
+                    columns=["date", "open", "high", "low", "close", "volume", "symbol"]
+                )
+
+            df = pd.DataFrame(resp.data)
+
+            # Extract symbol from joined table
+            df["symbol"] = df["instruments"].apply(lambda x: x["symbol"])
+            df = df.drop(columns=["instruments"])
+
+            # Convert date to datetime
+            df["date"] = pd.to_datetime(df["date"])
+
+            return df
+
+        except Exception as e:
+            logger.error(f"Failed to retrieve prices: {e}")
+            raise
+
+    def get_asset_prices(
+        self,
+        symbols: Optional[Union[str, List[str]]] = None,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+        column: str = "close",
+    ) -> pd.DataFrame:
+        """
+        Retrieve OHLCV data in wide format (symbols as columns).
+
+        Parameters
+        ----------
+        symbols : str | list[str], optional
+            Filter by symbol(s)
+        start_date : str, optional
+            Start date filter (YYYY-MM-DD)
+        end_date : str, optional
+            End date filter (YYYY-MM-DD)
+        column : str
+            Price column to pivot ('open', 'high', 'low', 'close', 'volume')
+
+        Returns
+        -------
+        DataFrame
+            Index: date, Columns: symbols
+        """
+        df = self.get_prices(symbols, start_date, end_date)
+
+        if df.empty:
+            return pd.DataFrame()
+
+        # Pivot to wide format
+        df_wide = df.pivot(index="date", columns="symbol", values=column)
+
+        return df_wide
+
+    def get_latest_prices(
+        self, symbols: Optional[Union[str, List[str]]] = None
+    ) -> pd.DataFrame:
+        """
+        Get the most recent price for each symbol.
+
+        Parameters
+        ----------
+        symbols : str | list[str], optional
+            Filter by symbol(s)
+
+        Returns
+        -------
+        DataFrame
+            Latest price record for each symbol
+        """
+        try:
+            # Build subquery for max date per instrument
+            if symbols:
+                if isinstance(symbols, str):
+                    symbols = [symbols]
+                
+                # Get instrument IDs
+                inst_resp = (
+                    self.supabase.table("instruments")
+                    .select("id, symbol")
+                    .in_("symbol", symbols)
+                    .execute()
+                )
+                
+                if not inst_resp.data:
+                    return pd.DataFrame()
+                
+                instrument_ids = [row["id"] for row in inst_resp.data]
+                symbol_map = {row["id"]: row["symbol"] for row in inst_resp.data}
+            else:
+                # Get all instruments
+                inst_resp = self.supabase.table("instruments").select("id, symbol").execute()
+                if not inst_resp.data:
+                    return pd.DataFrame()
+                
+                instrument_ids = [row["id"] for row in inst_resp.data]
+                symbol_map = {row["id"]: row["symbol"] for row in inst_resp.data}
+
+            # Get latest price for each instrument
+            all_latest = []
+            for inst_id in instrument_ids:
+                resp = (
+                    self.supabase.table("prices")
+                    .select("*")
+                    .eq("instrument_id", inst_id)
+                    .order("date", desc=True)
+                    .limit(1)
+                    .execute()
+                )
+                
+                if resp.data:
+                    record = resp.data[0]
+                    record["symbol"] = symbol_map[inst_id]
+                    all_latest.append(record)
+
+            if not all_latest:
+                return pd.DataFrame()
+
+            df = pd.DataFrame(all_latest)
+            df["date"] = pd.to_datetime(df["date"])
+            df = df.drop(columns=["instrument_id"])
+
+            return df[["symbol", "date", "open", "high", "low", "close", "volume"]]
+
+        except Exception as e:
+            logger.error(f"Failed to retrieve latest prices: {e}")
+            raise

{quantmod-0.1.2 → quantmod-0.1.3}/quantmod/markets/yahoo.py

@@ -5,75 +5,12 @@ import hashlib
 import os
 from typing import Union, List
 
-# # Directory to store cache files
-# CACHE_DIR = '.cache'
-
-# def _get_cache_file_name(tickers: Union[str, List[str]], start_date: str, end_date: str, period: str, interval: str) -> str:
-#     """
-#     Generate a cache file name based on the parameters.
-#     """
-#     if isinstance(tickers, str):
-#         tickers = [tickers]
-#     key = f"{','.join(tickers)}_{start_date}_{end_date}_{period}_{interval}"
-#     cache_key = hashlib.md5(key.encode()).hexdigest()
-#     return os.path.join(CACHE_DIR, f"{cache_key}.pkl")
-
-
-# def getData(tickers: Union[str, List[str]], start_date: str = None, end_date: str = None, period: str = '1mo', interval: str = '1d') -> pd.DataFrame:
-#     """
-#     Retrieve data from yfinance library for specified tickers, with caching.
-
-#     Parameters
-#     ----------
-#     tickers : str or list
-#         Symbol or list of symbols.
-#     start_date : str, optional
-#         Start date, by default None.
-#     end_date : str, optional
-#         End date, by default None.
-#     period : str, optional
-#         Period, by default '1mo'.
-#         Valid periods: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max.
-#     interval : str, optional
-#         Interval, by default '1d', max 60 days.
-#         Valid intervals: 1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo.
-
-#     Returns
-#     -------
-#     pd.DataFrame
-#         DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
-#     """
-#     # Ensure cache directory exists
-#     if not os.path.exists(CACHE_DIR):
-#         os.makedirs(CACHE_DIR)
-
-#     cache_file = _get_cache_file_name(tickers, start_date, end_date, period, interval)
-
-#     # Check if cached file exists
-#     if os.path.exists(cache_file):
-#         # print(f"Loading data from cache: {cache_file}")
-#         return joblib.load(cache_file)
-
-#     try:
-#         # Download data from yfinance
-#         data = yf.download(tickers, start=start_date, end=end_date, auto_adjust=True, progress=False, period=period, interval=interval)
-
-#         # Save data to cache
-#         joblib.dump(data, cache_file)
-#         # print(f"Data cached to: {cache_file}")
-
-#     except Exception as e:
-#         print(f"Error downloading data: {e}")
-#         raise
-
-#     return data
-
 
 def getData(
     tickers: Union[str, List[str]],
-    start_date: str = None,
-    end_date: str = None,
-    period: str = "1mo",
+    start_date: str | None = None,
+    end_date: str | None = None,
+    period: str | None = None,
     interval: str = "1d",
 ) -> pd.DataFrame:
     """
@@ -83,9 +20,9 @@ def getData(
     ----------
     tickers : str or list
         symbol or list of symbols
-    start : str, optional
+    start_date : str, optional
         start date, by default None
-    end : str, optional
+    end_date : str, optional
         end date, by default None
     period : str, optional
         period, by default '1mo'
@@ -99,6 +36,9 @@ def getData(
     pd.DataFrame
         DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
     """
+    
+    if period and (start_date or end_date):
+        raise ValueError("Use either period OR start_date/end_date, not both.")
 
     cols = ["Open", "High", "Low", "Close", "Volume"]
     data = yf.download(
@@ -157,3 +97,68 @@ def getTicker(ticker: str) -> yf.Ticker:
     # .news
 
     return yf.Ticker(ticker)
+
+
+
+# # Directory to store cache files
+# CACHE_DIR = '.cache'
+
+# def _get_cache_file_name(tickers: Union[str, List[str]], start_date: str, end_date: str, period: str, interval: str) -> str:
+#     """
+#     Generate a cache file name based on the parameters.
+#     """
+#     if isinstance(tickers, str):
+#         tickers = [tickers]
+#     key = f"{','.join(tickers)}_{start_date}_{end_date}_{period}_{interval}"
+#     cache_key = hashlib.md5(key.encode()).hexdigest()
+#     return os.path.join(CACHE_DIR, f"{cache_key}.pkl")
+
+
+# def getData(tickers: Union[str, List[str]], start_date: str = None, end_date: str = None, period: str = '1mo', interval: str = '1d') -> pd.DataFrame:
+#     """
+#     Retrieve data from yfinance library for specified tickers, with caching.
+
+#     Parameters
+#     ----------
+#     tickers : str or list
+#         Symbol or list of symbols.
+#     start_date : str, optional
+#         Start date, by default None.
+#     end_date : str, optional
+#         End date, by default None.
+#     period : str, optional
+#         Period, by default '1mo'.
+#         Valid periods: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max.
+#     interval : str, optional
+#         Interval, by default '1d', max 60 days.
+#         Valid intervals: 1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo.
+
+#     Returns
+#     -------
+#     pd.DataFrame
+#         DataFrame with OHLC[A]V (Open, High, Low, Close, Adj Close, Volume).
+#     """
+#     # Ensure cache directory exists
+#     if not os.path.exists(CACHE_DIR):
+#         os.makedirs(CACHE_DIR)
+
+#     cache_file = _get_cache_file_name(tickers, start_date, end_date, period, interval)
+
+#     # Check if cached file exists
+#     if os.path.exists(cache_file):
+#         # print(f"Loading data from cache: {cache_file}")
+#         return joblib.load(cache_file)
+
+#     try:
+#         # Download data from yfinance
+#         data = yf.download(tickers, start=start_date, end=end_date, auto_adjust=True, progress=False, period=period, interval=interval)
+
+#         # Save data to cache
+#         joblib.dump(data, cache_file)
+#         # print(f"Data cached to: {cache_file}")
+
+#     except Exception as e:
+#         print(f"Error downloading data: {e}")
+#         raise
+
+#     return data

{quantmod-0.1.2 → quantmod-0.1.3}/quantmod/models/optioninputs.py

@@ -3,17 +3,60 @@ from enum import Enum
 from typing import Optional
 
 class OptionType(str, Enum):
+    """Enum for option types"""
     CALL = "call"
     PUT = "put"
 
+    @classmethod
+    def from_string(cls, s: str):
+        """Convert string to OptionType"""
+        s = s.upper()
+        if s in ("CE", "CALL", "C"):
+            return cls.CALL
+        elif s in ("PE", "PUT", "P"):
+            return cls.PUT
+        raise ValueError(f"Invalid option type: {s}")
+    
 class ExerciseStyle(str, Enum):
     ASIAN = "asian"
     BARRIER = "barrier"
     EUROPEAN = "european"
     AMERICAN = "american"
+    
+    @classmethod
+    def from_string(cls, s: str):
+        """Convert string to OptionType"""
+        s = s.upper()
+        if s in ("asian", "Asian", "ASIAN"):
+            return cls.ASIAN
+        elif s in ("barrier", "Barrier", "BARRIER"):
+            return cls.BARRIER
+        elif s in ("european", "European", "EUROPEAN"):
+            return cls.EUROPEAN
+        elif s in ("american", "American", "AMERICAN"):
+            return cls.AMERICAN
+        raise ValueError(f"Invalid Exercise Style: {s}")
 
 class BarrierType(str, Enum):
     UP_AND_OUT = "up_and_out"
+    UP_AND_IN = "up_and_in"
+    DOWN_AND_OUT = "down_and_out"
+    DOWN_AND_IN = "down_and_in"
+
+    @classmethod
+    def from_string(cls, s: str):
+        """Convert string to BarrierType"""
+        s = s.upper()
+        if s in ("up_and_out", "Up_and_out", "UP_AND_OUT"):
+            return cls.UP_AND_OUT
+        elif s in ("up_and_in", "Up_and_in", "UP_AND_IN"):
+            return cls.UP_AND_IN
+        elif s in ("down_and_out", "Down_and_out", "DOWN_AND_OUT"):
+            return cls.DOWN_AND_OUT
+        elif s in ("down_and_in", "Down_and_in", "DOWN_AND_IN"):
+            return cls.DOWN_AND_IN
+        raise ValueError(f"Invalid Barrier Type: {s}")
+
 
 class OptionInputs(BaseModel):
     """

{quantmod-0.1.2 → quantmod-0.1.3}/quantmod/timeseries/performance.py

@@ -6,104 +6,97 @@ def periodReturn(
     data: pd.DataFrame | pd.Series, period: str = None
 ) -> pd.DataFrame | pd.Series:
     """
-    Calculates periodic returns for the specified inputs
-
+    Calculates periodic log returns. 
+    Updated for 2026 pandas frequency aliases (ME, QE, YE).
+    
     Parameters
     ----------
     data : pd.DataFrame | pd.Series
         price data
     period : str, optional
         None, defaults to daily frequency
-        Sepcifiy W, M, Q and Y for weekly, monthly, quarterly and annual frequency
+        Specify W, M, Q, or A for weekly, monthly, quarterly, and annual frequency
 
     Returns
     -------
-    pd.Series
-        resampled dataframe series of log returns
+    pd.Series or pd.DataFrame
+    Log returns at the specified frequency. If period="all",
+    returns a single-row DataFrame summarizing multiple horizons.
     """
-
-    # Check if the input is a Series or DataFrame
     if not isinstance(data, (pd.DataFrame, pd.Series)):
         raise ValueError("Input must be a pandas DataFrame or Series")
+    
+    # Resampling requires a time-based index
+    if period is not None and period != "all":
+        if not isinstance(data.index, (pd.DatetimeIndex, pd.PeriodIndex)):
+            raise ValueError(
+                "Data must have a DatetimeIndex or PeriodIndex for resampling"
+            )
 
-    # Initialize variable to hold log returns
-    if isinstance(data, pd.DataFrame):
-        temp = pd.DataFrame(dtype=float)
-    else:
-        temp = pd.Series(dtype=float)
+    # Mapping of input period to pandas frequency aliases
+    # Using 'ME', 'QE', 'YE' to follow modern pandas standards
+    freq_map = {"W": "W", "M": "ME", "Q": "QE", "A": "YE", "Y": "YE"}
 
     if period is None:
-        temp = np.log(data).diff()
-
-    elif period == "W":
-        data = data.resample("W").last()
-        temp = np.log(data).diff()
+        # Standard daily log return
+        return np.log(data).diff()
 
-    elif period == "M":
-        data = data.resample("ME").last()
-        temp = np.log(data).diff()
-
-    elif period == "Q":
-        data = data.resample("QE").last()
-        temp = np.log(data).diff()
-
-    elif period == "A":
-        data = data.resample("YE").last()
-        temp = np.log(data).diff()
+    elif period in freq_map:
+        # Resample to the end of the period, then calculate log return
+        resampled_data = data.resample(freq_map[period]).last()
+        return np.log(resampled_data).diff()
 
     elif period == "all":
-        if isinstance(data, pd.Series):
-            temp = pd.DataFrame(
-                {
-                    "daily": dailyReturn(data).iloc[-1],
-                    "weekly": weeklyReturn(data).iloc[-1],
-                    "monthly": monthlyReturn(data).iloc[-1],
-                    "quarterly": quarterlyReturn(data).iloc[-1],
-                    "annual": annualReturn(data).iloc[-1],
-                },
-                index=[data.index[-1]],
-            )
-            return temp
-        else:
+        if not isinstance(data, pd.Series):
             raise ValueError("Please pass a Series for period 'all'")
+        
+        # Construct summary using recursive calls or defined helpers
+        return pd.DataFrame({
+            "daily": periodReturn(data).iloc[-1],
+            "weekly": periodReturn(data, "W").iloc[-1],
+            "monthly": periodReturn(data, "M").iloc[-1],
+            "quarterly": periodReturn(data, "Q").iloc[-1],
+            "annual": periodReturn(data, "A").iloc[-1],
+        }, index=[data.index[-1]])
 
-    return temp
-
+    else:
+        raise ValueError(f"Invalid period '{period}' provided.")
+    
 
 def dailyReturn(data: pd.DataFrame | pd.Series) -> pd.DataFrame | pd.Series:
-    """Calculates daily returns for the specified inputs."""
+    """Calculates daily log returns."""
     return periodReturn(data)
 
 
 def weeklyReturn(data: pd.DataFrame | pd.Series) -> pd.DataFrame | pd.Series:
-    """Calculates weekly returns for the specified inputs."""
+    """Calculates weekly log returns."""
     return periodReturn(data, period="W")
 
 
 def monthlyReturn(data: pd.DataFrame | pd.Series) -> pd.DataFrame | pd.Series:
-    """Calculates monthly returns for the specified inputs."""
+    """Calculates monthly log returns."""
     return periodReturn(data, period="M")
 
 
 def quarterlyReturn(data: pd.DataFrame | pd.Series) -> pd.DataFrame | pd.Series:
-    """Calculates quarterly returns for the specified inputs."""
+    """Calculates quarterly log returns."""
     return periodReturn(data, period="Q")
 
 
 def annualReturn(data: pd.DataFrame | pd.Series) -> pd.DataFrame | pd.Series:
-    """Calculates annual returns for the specified inputs."""
+    """Calculates annual log returns."""
     return periodReturn(data, period="A")
 
 
-def allReturn(data: pd.Series) -> pd.Series:
-    """Calculates annual returns for the specified inputs."""
+def allReturn(data: pd.Series) -> pd.DataFrame:
+    """Returns a snapshot of latest log returns across multiple horizons."""
     return periodReturn(data, period="all")
 
 
 def rollingReturn(
     data: pd.DataFrame | pd.Series, window: int = 10
 ) -> pd.DataFrame | pd.Series:
-    """Calculates rolling returns for the specified inputs."""
+    """Calculates rolling log returns over the specified window."""
     return dailyReturn(data).rolling(window).sum()
 
 

quantmod-0.1.3/quantmod/version.py

@@ -0,0 +1 @@
+version = "0.1.3"

{quantmod-0.1.2 → quantmod-0.1.3}/quantmod.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: quantmod
-Version: 0.1.2
+Version: 0.1.3
 Summary: Quantmod Python Package
 Home-page: https://kannansingaravelu.com/
 Author: Kannan Singaravelu
@@ -28,9 +28,10 @@ Requires-Dist: plotly>=6.1.2
 Requires-Dist: pydantic>=2.8.2
 Requires-Dist: scipy>=1.13.1
 Requires-Dist: sqlalchemy>=2.0.38
+Requires-Dist: supabase>=2.27.2
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: urllib3==1.26.15
-Requires-Dist: yfinance==0.2.58
+Requires-Dist: yfinance>=1.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{quantmod-0.1.2 → quantmod-0.1.3}/quantmod.egg-info/SOURCES.txt

@@ -21,6 +21,8 @@ quantmod/datasets/__init__.py
 quantmod/datasets/dataloader.py
 quantmod/datasets/data/nifty50.csv
 quantmod/datasets/data/spx.csv
+quantmod/db/__init__.py
+quantmod/db/database.py
 quantmod/derivatives/__init__.py
 quantmod/derivatives/nse.py
 quantmod/indicators/__init__.py

{quantmod-0.1.2 → quantmod-0.1.3}/quantmod.egg-info/requires.txt

@@ -7,6 +7,7 @@ plotly>=6.1.2
 pydantic>=2.8.2
 scipy>=1.13.1
 sqlalchemy>=2.0.38
+supabase>=2.27.2
 tabulate>=0.9.0
 urllib3==1.26.15
-yfinance==0.2.58
+yfinance>=1.0

quantmod-0.1.2/quantmod/version.py

@@ -1 +0,0 @@
-version = "0.1.2"