pwb-toolbox 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

pwb_toolbox/datasets/__init__.py

@@ -627,7 +627,9 @@ def load_dataset(
     return df
 
 
-def __convert_indices_to_usd(df_indices, df_forex):
+def __convert_indices_to_usd(
+    df_indices: pd.DataFrame, df_forex: pd.DataFrame
+) -> pd.DataFrame:
     mapping = {
         "ADSMI": "AED",  # United Arab Emirates
         "AEX": "EUR",  # Netherlands
@@ -727,32 +729,40 @@ def __convert_indices_to_usd(df_indices, df_forex):
         "SX5E": "EUR",  # Europe
         "TA125": "ILS",  # Israel
     }
-    symbols = df_indices.symbol.unique()
-    mapping = {k: v for k, v in mapping.items() if k in symbols}
     frames = []
-    for symbol, currency in mapping.items():
-        df_index = df_indices[df_indices["symbol"] == symbol].copy()
-        if currency == "USD":
-            frames.append(df_index)
+
+    # iterate over the symbols that actually exist in df_indices
+    for symbol in df_indices["symbol"].unique():
+        df_idx = df_indices[df_indices["symbol"] == symbol].copy()
+
+        # 1) Figure out what currency the index is quoted in.
+        ccy = mapping.get(symbol)  # None if not mapped
+        if ccy is None or ccy == "USD":
+            # Unknown or already USD – just keep the original rows
+            frames.append(df_idx)
             continue
-        df_forex_currency = df_forex[df_forex["symbol"] == currency + "USD"].copy()
-        if df_index.empty or df_forex_currency.empty:
+
+        # 2) Find the matching FX rate (home-ccy → USD)
+        pair = ccy + "USD"
+        df_fx = df_forex[df_forex["symbol"] == pair].copy()
+
+        if df_idx.empty or df_fx.empty:
+            # No FX data – keep raw index levels instead of dropping them
+            frames.append(df_idx)
             continue
-        # Merge dataframes on the date column
-        merged_df = pd.merge(
-            df_index, df_forex_currency, on="date", suffixes=("", "_forex")
-        )
 
-        # Multiply the index prices by the corresponding forex rates
-        merged_df["open"] = merged_df["open"] * merged_df["open_forex"]
-        merged_df["high"] = merged_df["high"] * merged_df["high_forex"]
-        merged_df["low"] = merged_df["low"] * merged_df["low_forex"]
-        merged_df["close"] = merged_df["close"] * merged_df["close_forex"]
+        # 3) Merge on date and convert OHLC
+        merged = pd.merge(df_idx, df_fx, on="date", suffixes=("", "_fx"))
+        for col in ("open", "high", "low", "close"):
+            merged[col] = merged[col] * merged[f"{col}_fx"]
 
-        frames.append(merged_df[["symbol", "date", "open", "high", "low", "close"]])
+        frames.append(merged[["symbol", "date", "open", "high", "low", "close"]])
 
-    df = pd.concat(frames, ignore_index=True)
-    return df
+    if not frames:
+        return pd.DataFrame(columns=df_indices.columns)
+
+    # Combine everything back into one DataFrame
+    return pd.concat(frames, ignore_index=True)
 
 
 def __extract_years_to_maturity(bond_symbol):
@@ -803,62 +813,68 @@ def __extend_etfs(df_etfs):
     symbols = df_etfs.symbol.unique()
     mapping = {k: v for k, v in mapping.items() if k in symbols}
 
-    grouped_path_symbols = defaultdict(list)
-    for value in mapping.values():
-        grouped_path_symbols[value[0]].append(value[1])
-    grouped_path_symbols = dict(grouped_path_symbols)
-    df_others = pd.concat(
-        [
-            load_dataset(path, symbols, to_usd=True)
-            for path, symbols in grouped_path_symbols.items()
-        ]
-    )
+    # Nothing to extend → just return the input
+    if not mapping:
+        return df_etfs.copy()
+
+    # ------------------------------------------------------------------ step 2
+    grouped = defaultdict(list)  # {path: [proxy1, proxy2, ...]}
+    for _, (path, proxy) in mapping.items():
+        grouped[path].append(proxy)
+
+    # Load each dataset only if there's at least one proxy symbol
+    other_frames = []
+    for path, proxies in grouped.items():
+        if proxies:  # skip empty lists
+            other_frames.append(load_dataset(path, proxies, to_usd=True))
 
+    # If no proxy data could be loaded, fall back to raw ETF data
+    if not other_frames:
+        return df_etfs.copy()
+
+    df_others = pd.concat(other_frames, ignore_index=True)
+
+    # ------------------------------------------------------------------ step 3
     frames = []
-    for etf, other in mapping.items():
-        other_symbol = other[1]
-        # Get the ETF & Index data
+    for etf, (__, proxy) in mapping.items():
         etf_data = df_etfs[df_etfs["symbol"] == etf]
-        if etf_data.empty:
-            continue
-        other_data = df_others[df_others["symbol"] == other_symbol]
-        if other_data.empty:
-            continue
-
-        # Find the first overlapping date
-        common_dates = etf_data["date"].isin(other_data["date"])
-        first_common_date = etf_data.loc[common_dates, "date"].min()
+        proxy_data = df_others[df_others["symbol"] == proxy]
 
-        if pd.isnull(first_common_date):
-            print(f"No common date found for {etf} and {other_symbol}")
+        if etf_data.empty or proxy_data.empty:
+            frames.append(etf_data)  # keep raw ETF if proxy missing
             continue
 
-        etf_first_common = etf_data[etf_data["date"] == first_common_date]
-        other_first_common = other_data[other_data["date"] == first_common_date]
+        # Find first overlapping date
+        first_common = etf_data.loc[
+            etf_data["date"].isin(proxy_data["date"]), "date"
+        ].min()
+        if pd.isna(first_common):
+            frames.append(etf_data)  # no overlap → keep raw ETF
+            continue
 
-        # Compute the adjustment factor (using closing prices for simplicity)
-        adjustment_factor = (
-            etf_first_common["close"].values[0] / other_first_common["close"].values[0]
+        # Compute adjustment factor on that date
+        k = (
+            etf_data.loc[etf_data["date"] == first_common, "close"].iloc[0]
+            / proxy_data.loc[proxy_data["date"] == first_common, "close"].iloc[0]
         )
 
-        # Adjust index data before the first common date
-        index_data_before_common = other_data[
-            other_data["date"] < first_common_date
-        ].copy()
-        for column in ["open", "high", "low", "close"]:
-            index_data_before_common.loc[:, column] *= adjustment_factor
-        index_data_before_common.loc[:, "symbol"] = etf
+        # Scale proxy history before the overlap
+        hist = proxy_data[proxy_data["date"] < first_common].copy()
+        hist[["open", "high", "low", "close"]] *= k
+        hist["symbol"] = etf
 
-        # Combine adjusted index data with ETF data
-        combined_data = pd.concat([index_data_before_common, etf_data])
-        frames.append(combined_data)
+        # Combine proxy history + actual ETF data
+        frames.append(pd.concat([hist, etf_data]))
 
-    symbols_not_in_mapping = set(symbols) - set(mapping.keys())
-    frames.append(df_etfs[df_etfs["symbol"].isin(symbols_not_in_mapping)])
+    # Add ETFs that were never in the mapping
+    untouched = set(symbols) - set(mapping)
+    frames.append(df_etfs[df_etfs["symbol"].isin(untouched)])
 
-    # Concatenate all frames to form the final dataframe
-    df = pd.concat(frames).sort_values(by=["date", "symbol"]).reset_index(drop=True)
-    return df
+    return (
+        pd.concat(frames, ignore_index=True)
+        .sort_values(["date", "symbol"])
+        .reset_index(drop=True)
+    )
 
 
 ALLOWED_FIELDS = {"open", "high", "low", "close"}
@@ -909,16 +925,25 @@ def get_pricing(
         raise ValueError(f"Invalid field(s): {bad}. Allowed: {sorted(ALLOWED_FIELDS)}")
 
     # --------------------------------------------------------------- download
-    df = pd.concat(
-        [
-            load_dataset("Stocks-Daily-Price", symbol_list, extend=extend),
-            load_dataset("ETFs-Daily-Price", symbol_list, extend=extend),
-            load_dataset("Cryptocurrencies-Daily-Price", symbol_list, extend=extend),
-            load_dataset("Bonds-Daily-Price", symbol_list, extend=extend),
-            load_dataset("Commodities-Daily-Price", symbol_list, extend=extend),
-        ],
-        ignore_index=True,
-    )
+    DATASETS = [
+        ("Stocks-Daily-Price", extend),
+        ("ETFs-Daily-Price", extend),
+        ("Cryptocurrencies-Daily-Price", extend),
+        ("Bonds-Daily-Price", extend),
+        ("Commodities-Daily-Price", extend),
+        ("Forex-Daily-Price", extend),
+        ("Indices-Daily-Price", False),  # indices generally have no proxy data
+    ]
+    remaining = set(symbol_list)  # symbols still to fetch
+    frames = []
+    for dataset_name, ext_flag in DATASETS:
+        if not remaining:  # all symbols resolved → stop early
+            break
+        df_part = load_dataset(dataset_name, list(remaining), extend=ext_flag)
+        if not df_part.empty:
+            frames.append(df_part)
+            remaining -= set(df_part["symbol"].unique())
+    df = pd.concat(frames, ignore_index=True)
 
     df["date"] = pd.to_datetime(df["date"])
     df.set_index("date", inplace=True)

{pwb_toolbox-0.1.4.dist-info → pwb_toolbox-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pwb-toolbox
-Version: 0.1.4
+Version: 0.1.6
 Summary: A toolbox library for quant traders
 Home-page: https://github.com/paperswithbacktest/pwb-toolbox
 Author: Your Name

pwb_toolbox-0.1.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+pwb_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pwb_toolbox/datasets/__init__.py,sha256=8ruFquxyz5_6D9zImecPmTXruHClkoV0vNX5H0eR4Fw,22249
+pwb_toolbox-0.1.6.dist-info/licenses/LICENSE.txt,sha256=_Wjz7o7St3iVSPBRzE0keS8XSqSJ03A3NZ6cMlTaSK8,1079
+pwb_toolbox-0.1.6.dist-info/METADATA,sha256=nao3Zw_tNUmsNxm9tql9HfYc3NAOWc_wyJIaYcuuHBA,4617
+pwb_toolbox-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pwb_toolbox-0.1.6.dist-info/top_level.txt,sha256=TZcXcF2AMkKkibZOuq6AYsHjajPgddHAGjQUT64OYGY,12
+pwb_toolbox-0.1.6.dist-info/RECORD,,

pwb_toolbox-0.1.4.dist-info/RECORD

@@ -1,7 +0,0 @@
-pwb_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pwb_toolbox/datasets/__init__.py,sha256=drj-jY3HSxYp8o1X8-hYbDvaHzuVR4JRumrXq-_CQFk,21668
-pwb_toolbox-0.1.4.dist-info/licenses/LICENSE.txt,sha256=_Wjz7o7St3iVSPBRzE0keS8XSqSJ03A3NZ6cMlTaSK8,1079
-pwb_toolbox-0.1.4.dist-info/METADATA,sha256=ai7OJKVjtSVmZbjZFH_dbqSD5pebe57j_xCw1yhAt20,4617
-pwb_toolbox-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pwb_toolbox-0.1.4.dist-info/top_level.txt,sha256=TZcXcF2AMkKkibZOuq6AYsHjajPgddHAGjQUT64OYGY,12
-pwb_toolbox-0.1.4.dist-info/RECORD,,