pivotalpath 1.0.0__tar.gz

pivotalpath-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pivotalpath
+Version: 1.0.0
+Summary: The industry standard for hedge fund indices data and analytics
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Requires-Python: >=3.7

pivotalpath-1.0.0/README.md

@@ -0,0 +1,35 @@
+# PivotalPath
+
+The industry standard for hedge fund indices data and analytics.
+
+## Installation
+
+```bash
+pip install pivotalpath
+```
+
+## Quick Start
+
+```python
+import pivotalpath as pp
+
+# See available tickers
+print(pp.examples.example1())
+
+# Get fund returns
+returns = pp.get_returns("PP-HFC")
+
+# Calculate performance stats
+stats = pp.get_stats(target="PP-HFC", base="SP500", stat="sharpe")
+```
+
+## Features
+
+- Comprehensive hedge fund performance analytics
+- 20+ institutional-quality metrics
+- Real-time data API integration  
+- LLM-optimized for AI integration
+
+## License
+
+MIT

pivotalpath-1.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pivotalpath"
+version = "1.0.0"
+description = "The industry standard for hedge fund indices data and analytics"
+authors = [{name = "Your Name", email = "your.email@example.com"}]
+license = {text = "MIT"}
+requires-python = ">=3.7"
+dependencies = [
+    "pandas>=1.3.0",
+    "numpy>=1.20.0",
+    "requests>=2.25.0",
+    "python-dateutil>=2.8.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

pivotalpath-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pivotalpath-1.0.0/src/pivotalpath/__init__.py

@@ -0,0 +1,65 @@
+"""
+PivotalPath: The Industry Standard for Hedge Fund INDEX Analytics
+
+Analyzes hedge fund indices - composite benchmarks tracking groups of hedge funds.
+"""
+
+from .version import __version__
+
+# Core functionality
+from .core.main_library import (
+    get_catalog,
+    get_returns, 
+    get_info,
+    get_asset_list,
+    get_stats,
+    get_stats_list,
+)
+
+# Important tickers and examples
+from .core import important_tickers
+from .core import examples
+
+# Stats catalog  
+from .stats.catalog import stats_catalog
+
+# LLM-optimized interface for hedge fund indices
+try:
+    from .llm.interface import (
+        quick_index_stats,
+        analyze_hedge_fund_index,
+        compare_hedge_fund_indices,
+        list_hedge_fund_indices,
+        list_available_metrics,
+        generate_index_report,
+    )
+    LLM_AVAILABLE = True
+except ImportError as e:
+    print(f"LLM interface import failed: {e}")
+    LLM_AVAILABLE = False
+
+# Export everything
+__all__ = [
+    "__version__",
+    "get_catalog",
+    "get_returns",
+    "get_info", 
+    "get_asset_list",
+    "get_stats",
+    "get_stats_list",
+    "stats_catalog",
+    "important_tickers",
+    "examples",
+    "LLM_AVAILABLE",
+]
+
+# Add LLM functions if available
+if LLM_AVAILABLE:
+    __all__.extend([
+        "quick_index_stats",
+        "analyze_hedge_fund_index",
+        "compare_hedge_fund_indices", 
+        "list_hedge_fund_indices",
+        "list_available_metrics",
+        "generate_index_report",
+    ])

pivotalpath-1.0.0/src/pivotalpath/core/__init__.py

@@ -0,0 +1,24 @@
+"""Core functionality for hedge fund analysis."""
+
+from .main_library import (
+    get_catalog,
+    get_returns, 
+    get_info,
+    get_asset_list,
+    get_stats,
+    get_stats_list,
+)
+
+from . import important_tickers
+from . import examples
+
+__all__ = [
+    "get_catalog",
+    "get_returns",
+    "get_info",
+    "get_asset_list", 
+    "get_stats",
+    "get_stats_list",
+    "important_tickers",
+    "examples",
+]

pivotalpath-1.0.0/src/pivotalpath/core/examples.py

@@ -0,0 +1,86 @@
+
+from . import main_library as mli
+from . import important_tickers as it
+
+"""
+USECASES AND EXAMPLES OF THE MAIN LIBRARY FUNCTIONS
+
+"""
+
+"""
+example1: example of tickers
+"""
+def example1():
+    return [it.market_ticker, it.riskfree_ticker, it.hedge_fund_composite_index_ticker]
+
+"""
+example2: hedge fund index catalog
+"""
+def example2():
+    return mli.get_catalog(asset_class="index")
+
+"""
+example3: list all hedge fund index tickers
+"""
+def example3():
+    return mli.get_asset_list(asset_class="index")
+
+"""
+example4: list all hedge fund index names
+"""
+def example4():
+    return mli.get_asset_list(asset_class="index", select="name")
+"""
+example5: market returns
+"""
+def example5():
+    return mli.get_returns(ticker=it.market_ticker)
+
+"""
+example6: list available stats tickers
+""" 
+def example6():
+    return mli.get_stats_list()
+"""
+example7: list available stats names
+"""
+def example7():
+    return mli.get_stats_list(select="name")
+"""
+example8: example stats for first 2 hedge fund indices
+"""     
+def example8():
+    return mli.get_stats(
+        target=mli.get_asset_list(asset_class="index")[:2],
+        base=it.market_ticker,
+        start="2020-01",
+        end="2024-12",
+        stat=['annret','annvol','sharpe']
+        )
+
+"""
+example9: example stats with custom labels
+"""
+def example9():
+    return mli.get_stats(
+        target=mli.get_asset_list(asset_class='index')+['SP500'],
+        base=it.market_ticker,
+        start="2020-01",
+        end="2024-12",
+        stat=mli.get_stats_list(),
+        label_as="shortname",
+        )
+"""
+example10: example structured stats
+""" 
+def example10():
+    return mli.get_stats(
+        target=mli.get_asset_list(asset_class='index'),
+        base=it.market_ticker,
+        start="2020-01",
+        end="2024-12",
+        stat=['sharpe','annvol'],
+        label_as="name+period",
+        index_as="name",
+    )   
+

pivotalpath-1.0.0/src/pivotalpath/core/important_tickers.py

@@ -0,0 +1,3 @@
+market_ticker="SP500"
+riskfree_ticker="TBILL3M"
+hedge_fund_composite_index_ticker="PP-HFC"

pivotalpath-1.0.0/src/pivotalpath/core/main_library.py

@@ -0,0 +1,47 @@
+
+from ..data import get_catalog, get_returns, get_info
+from ..stats import stats_calculator,stats_catalog
+import pandas as pd
+
+def _notdf(df):
+    return not(df is None) and not (isinstance(df,pd.DataFrame))
+
+def get_stats(
+        target=None,
+        base=None,
+        riskfree=None,
+        index_as="ticker",
+        transpose=False,
+        **kwargs
+    ):
+    if _notdf(target):
+        target=get_returns(ticker=target)
+    if _notdf(base):
+        base=get_returns(ticker=base)
+    if _notdf(riskfree):   
+        riskfree=get_returns(ticker=riskfree)
+        return pd.DataFrame()
+    df=stats_calculator(target=target,base=base,riskfree=riskfree,**kwargs)
+    if isinstance(index_as,str) and index_as!="ticker":
+        try:
+            df_info=get_info(ticker=df.index.tolist())
+            if isinstance(df_info,pd.DataFrame) and not (df_info.empty):
+                info_map=df_info.set_index("ticker")[index_as].to_dict()
+                df.index=[info_map.get(_,_) for _ in df.index.tolist()]
+            df.index=df[index_as]
+            df.index.name=index_as
+        except:
+            pass
+    if transpose:
+        df=df.T
+    return df
+
+
+def get_stats_list(select="ticker")->list:
+    return [_.get(select) for _ in stats_catalog]
+
+def get_asset_list(asset_class="index",select="ticker")->list:
+    df=get_catalog(asset_class=asset_class,select=select)
+    if isinstance(df,pd.DataFrame) and not (df.empty):
+        return df[select].tolist()  
+    return []

pivotalpath-1.0.0/src/pivotalpath/data/__init__.py

@@ -0,0 +1,115 @@
+
+import pandas as pd
+from .api import GetFilteredDataFrame
+from . import utils as tsutil
+
+def _ticker2class(ticker):
+    if isinstance(ticker,list):
+        return [_ticker2class(_) for _ in ticker]
+    else:
+        # tba: add confirmation
+        if ticker.startswith("PP"):
+            return "index"
+        else:
+            return "factor"
+            
+def _ticker2map(ticker=[]):
+    out=dict(
+        index=[_ for _ in ticker if _.startswith("PP")],
+        factor=[_ for _ in ticker if not (_.startswith("PP"))]
+    )
+    return {_:__ for _,__ in out.items() if __}
+
+
+"""
+main functions
+"""
+
+def get_catalog(asset_class="index",filter_by=dict(),select="*")->pd.DataFrame:
+    if isinstance(asset_class,list):
+        df=pd.DataFrame()
+        for _ in asset_class:
+            df_i=get_catalog(asset_class=_,filter_by=filter_by,select="*")
+            df=pd.concat([df,df_i]).set_index("ticker")
+        return df
+    table_name=f"{asset_class}_catalog"
+    return GetFilteredDataFrame(table_name,filter_by=filter_by)
+    
+
+def get_info(ticker=None):
+
+    if not ticker:
+        return {}
+
+    if isinstance(ticker,str):
+        asset_class=_ticker2class(ticker)
+        table_name=f"{asset_class}_catalog"
+        return GetFilteredDataFrame(table_name,filter_by=dict(ticker=ticker)).iloc[0].to_dict()
+    
+    if isinstance(ticker,list):
+        tickermap=_ticker2map(ticker)
+        out=pd.DataFrame()
+        for asset_i,ticker_i in tickermap.items():
+            table_name=f"{asset_i}_catalog"
+            df_i=GetFilteredDataFrame(table_name, filter_by=dict(ticker=ticker_i))
+            if isinstance(df_i,pd.DataFrame) and not (df_i.empty):
+                out=pd.concat([out,df_i],axis=0)
+        return out
+    
+
+def get_returns(
+        ticker=[],
+        month_list=[],
+        start=None,
+        end=None,
+        lookback=None,
+        column_label="ticker",
+        freq="M",
+        freq_aggregation="compounded",
+        annualized=False,
+        rounding_places=6,
+        pivot=True,
+        
+    )->pd.DataFrame:
+
+    """
+    Get returns data for specified tickers.
+    
+    Returns:
+        pd.DataFrame or None: DataFrame with returns data, or None if no ticker provided
+    """
+    if not ticker:
+        return pd.DataFrame()
+    if isinstance(ticker,str):
+        ticker=[ticker]
+    tickermap=_ticker2map(ticker=ticker)
+    if not month_list:
+        month_list=tsutil.build_month_list(start=start,end=end,lookback=lookback)
+    df=pd.DataFrame()
+    for asset_i, ticker_i in tickermap.items(): 
+        table_name=f"{asset_i}_returns"
+        rows=GetFilteredDataFrame(table_name, filter_by=dict(ticker=ticker_i))
+        if start:
+            rows=rows[rows['month']>=start]
+        if end:
+            rows=rows[rows['month']<=end]   
+
+        if df.empty:
+            df=rows
+        else:
+            df=pd.concat([df,rows])
+            
+    df=df[df['ticker'].isin(ticker)]
+    if freq!="M":
+        pivot=True
+
+    if pivot:
+        df=df.pivot_table(index='month', columns='ticker', values='return')
+        df=df[[_ for _ in ticker if _ in df.columns]]
+    
+    if freq!="M":
+        df=tsutil.frequency_aggregation(df, freq=freq,freq_aggregation=freq_aggregation,annualized=annualized)
+       
+    return round(df,rounding_places)
+
+    

pivotalpath-1.0.0/src/pivotalpath/data/api.py

@@ -0,0 +1,35 @@
+
+import pandas as pd
+import warnings
+import requests
+
+class ApiCaller:
+    
+    base_url = "http://apps.pivotalpath.com/p3ypi/resources/api/v1/"
+    api_key = "p3k_7H9mK2pL8qX3nR5vW1cY4jZ6sA0uE9"
+    
+    @classmethod
+    def get_headers(cls):
+        return {
+            "Authorization": f"Bearer {cls.api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    @classmethod
+    def get_data(cls,endpoint=None,params=dict()):
+        url=cls.base_url+endpoint
+        headers=cls.get_headers()
+        response=requests.get(url,headers=headers,params=params)
+        if response.status_code==200:
+            try:
+                return pd.DataFrame(response.json())
+            except ValueError:
+                warnings.warn("Failed to parse JSON response")
+                return pd.DataFrame()
+        else:
+            warnings.warn(f"API call failed with status code {response.status_code}")
+            return pd.DataFrame()
+
+
+def GetFilteredDataFrame(table_name=None, filter_by=dict())->pd.DataFrame:
+    return ApiCaller.get_data(endpoint=table_name,params=filter_by)

pivotalpath-1.0.0/src/pivotalpath/data/utils.py

@@ -0,0 +1,40 @@
+import pandas as pd
+
+def _do_compound(df):
+    return (1 +df).prod(min_count=1) - 1
+def _do_sum(df):
+    return df.sum()
+def _compute_default_end():
+    return (pd.Timestamp.today()-pd.DateOffset(months=1)).strftime("%Y-%m")
+def _compute_default_start():
+    return "1998-01"
+
+
+def build_month_list(start=None,end=None,lookback=None, _default_start="1998-01",_default_rule="rule_of_7"):
+    if not end:
+        end=_compute_default_end()
+    if not start:
+        if lookback:
+            start=(pd.Timestamp(end)-pd.DateOffset(months=lookback-1)).strftime("%Y-%m")
+        else:
+            start=_compute_default_start()
+    return [_.strftime("%Y-%m") for _ in pd.period_range(start=start,end=end,freq="M")]
+
+def timeseries_aggregation(df,freq="Q",freq_aggregation="compounded",annualized=False,rounding_places=6):
+    if not isinstance(df.index, pd.DatetimeIndex):
+        df.index = pd.to_datetime(df.index, format='%Y-%m')
+    df_agg=df.resample(freq)
+    if freq_aggregation=="compounded":
+        out=df_agg.apply(_do_compound)
+        if annualized:
+            out=(1+out)**4-1
+    elif freq_aggregation=="sum":
+        out= df_agg.apply(_do_sum)
+        if annualized:
+            out=4*out
+    if rounding_places:
+        out=round(out,rounding_places)
+    out.index=out.index.to_period(freq).astype(str)
+    if freq=="Y":
+        out.index=[f"Y{_}" for _ in out.index]
+    return out

pivotalpath-1.0.0/src/pivotalpath/llm/__init__.py

@@ -0,0 +1,19 @@
+"""LLM-optimized interface for hedge fund index analysis."""
+
+from .interface import (
+    quick_index_stats,
+    analyze_hedge_fund_index,
+    compare_hedge_fund_indices,
+    list_hedge_fund_indices,
+    list_available_metrics,
+    generate_index_report,
+)
+
+__all__ = [
+    "quick_index_stats",
+    "analyze_hedge_fund_index",
+    "compare_hedge_fund_indices",
+    "list_hedge_fund_indices",
+    "list_available_metrics", 
+    "generate_index_report",
+]