sovai 0.2.0__tar.gz → 0.2.2__tar.gz

{sovai-0.2.0 → sovai-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sovai
-Version: 0.2.0
+Version: 0.2.2
 Summary: python for asset management
 License: Proprietary License
 Author: Derek Snow
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: boto3 (>=1.20)
 Requires-Dist: dash (>=2.0)
 Requires-Dist: great-tables (>=0.9)
+Requires-Dist: ipywidgets (>=8.1.3,<9.0.0)
 Requires-Dist: joblib (>=1.0)
 Requires-Dist: lightgbm (>=4.5.0,<5.0.0)
 Requires-Dist: matplotlib (>=3.0)
@@ -25,6 +26,7 @@ Requires-Dist: pandas (>=1.0)
 Requires-Dist: pexpect (>=4.9.0,<5.0.0)
 Requires-Dist: plotly (>=5.0)
 Requires-Dist: polars (>=0.20.30)
+Requires-Dist: polars-talib (==0.1.3)
 Requires-Dist: pyarrow (>=5.0)
 Requires-Dist: python-dateutil (>=2.8)
 Requires-Dist: python-dotenv (>=0.10)

{sovai-0.2.0 → sovai-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sovai"
-version = "0.2.0"
+version = "0.2.2"
 description = "python for asset management"
 authors = ["Derek Snow <d.snow@outlook.com>"]
 license = "Proprietary License"
@@ -56,6 +56,8 @@ openai = ">=1.0"
 mfles = ">=0.2"
 pexpect = "^4.9.0"
 lightgbm = "^4.5.0"
+ipywidgets = "^8.1.3"
+polars-talib = "0.1.3"
 
 [build-system]
 requires = ["poetry-core"]

{sovai-0.2.0 → sovai-0.2.2}/sovai/__init__.py

@@ -19,6 +19,16 @@ from .extensions.pandas_extensions import CustomDataFrame as extension
 from .utils.file_management import save_or_update_tickers
 
 
+
+from .get_tools import sec_search
+
+from .get_tools import sec_filing
+
+
+
+
+
+
 # Call the function to ensure tickers data is up-to-date
 save_or_update_tickers()
 

{sovai-0.2.0 → sovai-0.2.2}/sovai/extensions/pandas_extensions.py

@@ -76,6 +76,8 @@ from sovai.extensions.weight_optimization import WeightOptimization
 
 from sovai.extensions.signal_evaluation import SignalEvaluator
 
+from sovai.extensions.technical_indicators import techn_indicators
+
 
 import warnings
 
@@ -908,6 +910,17 @@ class CustomDataFrame(pd.DataFrame):
         )
 
         return CustomDataFrame(avg_shap_values)
+    
+    def technical_indicators(self):
+        """
+        Computes feature importance using SHAP values based on multiple simulations.
+
+        :param num_simulations: The number of simulations to run (default 4).
+        :param clustering_method: The clustering method to use ('OPTICS' or 'KMeans').
+        :return: A DataFrame with average SHAP values per feature.
+        """
+
+        return CustomDataFrame(techn_indicators(self))
 
 
 # # Example usage

sovai-0.2.2/sovai/extensions/technical_indicators.py

@@ -0,0 +1,219 @@
+import polars as pl
+import polars_talib as plta
+import warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+def func_ts_date(df_group: pl.DataFrame) -> pl.DataFrame:
+    # Ensure the data is sorted by date
+    df_group = df_group.sort("date")
+    
+    # Calculate technical indicators
+    df_group = df_group.with_columns([
+        plta.bbands(timeperiod=20, nbdevup=2, nbdevdn=2).alias('BBANDS'),
+        plta.ema(timeperiod=20).alias('EMA_20'),
+        plta.macd(fastperiod=12, slowperiod=26, signalperiod=9).alias('MACD'),
+        plta.adx(timeperiod=14).alias('ADX_14'),
+        plta.cci(timeperiod=14).alias('CCI_14'),
+        plta.mfi(timeperiod=14).alias('MFI_14'),
+        plta.mom(timeperiod=10).alias('MOM_10'),
+        plta.stoch(fastk_period=5, slowk_period=3, slowd_period=3).alias('STOCH'),
+        plta.willr(timeperiod=14).alias('WILLR_14'),
+        plta.atr(timeperiod=14).alias('ATR_14'),
+        plta.obv().alias('OBV'),
+        plta.ad().alias('AD'),
+        plta.aroon(timeperiod=14).alias('AROON_14'),
+        plta.bop().alias('BOP'),
+        plta.cmo(timeperiod=14).alias('CMO_14'),
+        plta.dx(timeperiod=14).alias('DX_14'),
+        plta.kama(timeperiod=30).alias('KAMA_30'),
+        plta.ppo().alias('PPO'),
+        plta.rocr(timeperiod=10).alias('ROCR_10'),
+        plta.trix(timeperiod=30).alias('TRIX_30'),
+        plta.ultosc().alias('ULTOSC'),
+        plta.natr(timeperiod=14).alias('NATR_14'),
+        plta.ht_dcperiod().alias('HT_DCPERIOD'),
+        plta.ht_dcphase().alias('HT_DCPHASE'),
+        plta.ht_phasor().alias('HT_PHASOR'),
+        plta.ht_sine().alias('HT_SINE'),
+        plta.ht_trendmode().alias('HT_TRENDMODE'),
+        plta.avgprice().alias('AVGPRICE'),
+        plta.medprice().alias('MEDPRICE'),
+        plta.typprice().alias('TYPPRICE'),
+        plta.wclprice().alias('WCLPRICE'),
+        plta.beta(timeperiod=5).alias('BETA_5'),
+        plta.correl(timeperiod=30).alias('CORREL_30'),
+        plta.linearreg(timeperiod=14).alias('LINEARREG_14'),
+        plta.linearreg_angle(timeperiod=14).alias('LINEARREG_ANGLE_14'),
+        plta.linearreg_intercept(timeperiod=14).alias('LINEARREG_INTERCEPT_14'),
+        plta.linearreg_slope(timeperiod=14).alias('LINEARREG_SLOPE_14'),
+        plta.tsf(timeperiod=14).alias('TSF_14'),
+        plta.var(timeperiod=5).alias('VAR_5'),
+        plta.sar(acceleration=0.02, maximum=0.2).alias('SAR'),
+        plta.adxr(timeperiod=14).alias('ADXR_14'),
+        plta.apo(fastperiod=12, slowperiod=26, matype=0).alias('APO'),
+        plta.aroonosc(timeperiod=14).alias('AROONOSC_14'),
+        plta.dema(timeperiod=30).alias('DEMA_30'),
+        plta.ht_trendline().alias('HT_TRENDLINE'),
+        plta.ma(timeperiod=30, matype=0).alias('MA_30'),
+        plta.mama().alias('MAMA'),
+        plta.mavp(periods=pl.col("volume"), minperiod=2, maxperiod=30, matype=0).alias('MAVP'),
+        plta.midpoint(timeperiod=14).alias('MIDPOINT_14'),
+        plta.midprice(timeperiod=14).alias('MIDPRICE_14'),
+        plta.sarext().alias('SAREXT'),
+        plta.sma(timeperiod=30).alias('SMA_30'),
+        plta.t3(timeperiod=5, vfactor=0.7).alias('T3_5'),
+        plta.tema(timeperiod=30).alias('TEMA_30'),
+        plta.trima(timeperiod=30).alias('TRIMA_30'),
+        plta.wma(timeperiod=30).alias('WMA_30'),
+        plta.cdl2crows().alias('CDL2CROWS'),
+        plta.cdl3blackcrows().alias('CDL3BLACKCROWS'),
+        plta.cdl3inside().alias('CDL3INSIDE'),
+        plta.cdl3linestrike().alias('CDL3LINESTRIKE'),
+        plta.cdl3outside().alias('CDL3OUTSIDE'),
+        plta.cdl3starsinsouth().alias('CDL3STARSINSOUTH'),
+        plta.cdl3whitesoldiers().alias('CDL3WHITESOLDIERS'),
+        plta.cdlabandonedbaby().alias('CDLABANDONEDBABY'),
+        plta.cdladvanceblock().alias('CDLADVANCEBLOCK'),
+        plta.cdlbelthold().alias('CDLBELTHOLD'),
+        plta.cdlbreakaway().alias('CDLBREAKAWAY'),
+        plta.cdlclosingmarubozu().alias('CDLCLOSINGMARUBOZU'),
+        plta.cdlconcealbabyswall().alias('CDLCONCEALBABYSWALL'),
+        plta.cdlcounterattack().alias('CDLCOUNTERATTACK'),
+        plta.cdldarkcloudcover().alias('CDLDARKCLOUDCOVER'),
+        plta.cdldoji().alias('CDLDOJI'),
+        plta.cdldojistar().alias('CDLDOJISTAR'),
+        plta.cdldragonflydoji().alias('CDLDRAGONFLYDOJI'),
+        plta.cdlengulfing().alias('CDLENGULFING'),
+        plta.cdleveningdojistar().alias('CDLEVENINGDOJISTAR'),
+        plta.cdleveningstar().alias('CDLEVENINGSTAR'),
+        plta.cdlgapsidesidewhite().alias('CDLGAPSIDESIDEWHITE'),
+        plta.cdlgravestonedoji().alias('CDLGRAVESTONEDOJI'),
+        plta.cdlhammer().alias('CDLHAMMER'),
+        plta.cdlhangingman().alias('CDLHANGINGMAN'),
+        plta.cdlharami().alias('CDLHARAMI'),
+        plta.cdlharamicross().alias('CDLHARAMICROSS'),
+        plta.cdlhighwave().alias('CDLHIGHWAVE'),
+        plta.cdlhikkake().alias('CDLHIKKAKE'),
+        plta.cdlhikkakemod().alias('CDLHIKKAKEMOD'),
+        plta.cdlhomingpigeon().alias('CDLHOMINGPIGEON'),
+        plta.cdlidentical3crows().alias('CDLIDENTICAL3CROWS'),
+        plta.cdlinneck().alias('CDLINNECK'),
+        plta.cdlinvertedhammer().alias('CDLINVERTEDHAMMER'),
+        plta.cdlkicking().alias('CDLKICKING'),
+        plta.cdlkickingbylength().alias('CDLKICKINGBYLENGTH'),
+        plta.cdlladderbottom().alias('CDLLADDERBOTTOM'),
+        plta.cdllongleggeddoji().alias('CDLLONGLEGGEDDOJI'),
+        plta.cdllongline().alias('CDLLONGLINE'),
+        plta.cdlmarubozu().alias('CDLMARUBOZU'),
+        plta.cdlmatchinglow().alias('CDLMATCHINGLOW'),
+        plta.cdlmathold().alias('CDLMATHOLD'),
+        plta.cdlmorningdojistar().alias('CDLMORNINGDOJISTAR'),
+        plta.cdlmorningstar().alias('CDLMORNINGSTAR'),
+        plta.cdlonneck().alias('CDLONNECK'),
+        plta.cdlpiercing().alias('CDLPIERCING'),
+        plta.cdlrickshawman().alias('CDLRICKSHAWMAN'),
+        plta.cdlrisefall3methods().alias('CDLRISEFALL3METHODS'),
+        plta.cdlseparatinglines().alias('CDLSEPARATINGLINES'),
+        plta.cdlshootingstar().alias('CDLSHOOTINGSTAR'),
+        plta.cdlshortline().alias('CDLSHORTLINE'),
+        plta.cdlspinningtop().alias('CDLSPINNINGTOP'),
+        plta.cdlstalledpattern().alias('CDLSTALLEDPATTERN'),
+        plta.cdlsticksandwich().alias('CDLSTICKSANDWICH'),
+        plta.cdltakuri().alias('CDLTAKURI'),
+        plta.cdltasukigap().alias('CDLTASUKIGAP'),
+        plta.cdlthrusting().alias('CDLTHRUSTING'),
+        plta.cdltristar().alias('CDLTRISTAR'),
+        plta.cdlunique3river().alias('CDLUNIQUE3RIVER'),
+        plta.cdlupsidegap2crows().alias('CDLUPSIDEGAP2CROWS'),
+        plta.cdlxsidegap3methods().alias('CDLXSIDEGAP3METHODS'),
+        plta.trange().alias('TRANGE'),
+        plta.adosc(fastperiod=3, slowperiod=10).alias('ADOSC'),
+        plta.roc(timeperiod=10).alias('ROC_10'),
+        plta.rocp(timeperiod=10).alias('ROCP_10'),
+        plta.rocr100(timeperiod=10).alias('ROCR100_10'),
+        plta.rsi(timeperiod=14).alias('RSI_14'),
+        plta.stochf(fastk_period=5, fastd_period=3, fastd_matype=0).alias('STOCHF'),
+        plta.stochrsi(timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0).alias('STOCHRSI'),
+        plta.add(pl.col("high")).alias('ADD'),
+        plta.div(pl.col("high")).alias('DIV'),
+        plta.max(timeperiod=30).alias('MAX_30'),
+        plta.maxindex(timeperiod=30).alias('MAXINDEX_30'),
+        plta.min(timeperiod=30).alias('MIN_30'),
+        plta.minindex(timeperiod=30).alias('MININDEX_30'),
+        plta.minmax(timeperiod=30).alias('MINMAX_30'),
+        plta.minmaxindex(timeperiod=30).alias('MINMAXINDEX_30'),
+        plta.mult(pl.col("high")).alias('MULT'),
+        plta.sub(pl.col("high")).alias('SUB'),
+        plta.sum(timeperiod=30).alias('SUM_30'),
+        plta.acos().alias('ACOS'),
+        plta.asin().alias('ASIN'),
+        plta.atan().alias('ATAN'),
+        plta.ceil().alias('CEIL'),
+        plta.cos().alias('COS'),
+        plta.cosh().alias('COSH'),
+        plta.exp().alias('EXP'),
+        plta.floor().alias('FLOOR'),
+        plta.ln().alias('LN'),
+        plta.log10().alias('LOG10'),
+        plta.sin().alias('SIN'),
+        plta.sinh().alias('SINH'),
+        plta.sqrt().alias('SQRT'),
+        plta.tan().alias('TAN'),
+        plta.tanh().alias('TANH'),
+        plta.stddev(timeperiod=5).alias('STDDEV_5'),
+    ])
+    
+    # Handle multi-value returns
+    df_group = df_group.with_columns([
+        pl.col('BBANDS').struct.field('upperband').alias('BBANDS_upper'),
+        pl.col('BBANDS').struct.field('middleband').alias('BBANDS_middle'),
+        pl.col('BBANDS').struct.field('lowerband').alias('BBANDS_lower'),
+        pl.col('MACD').struct.field('macd').alias('MACD_macd'),
+        pl.col('MACD').struct.field('macdsignal').alias('MACD_signal'),
+        pl.col('MACD').struct.field('macdhist').alias('MACD_hist'),
+        pl.col('STOCH').struct.field('slowk').alias('STOCH_slowk'),
+        pl.col('STOCH').struct.field('slowd').alias('STOCH_slowd'),
+        pl.col('AROON_14').struct.field('aroondown').alias('AROON_down'),
+        pl.col('AROON_14').struct.field('aroonup').alias('AROON_up'),
+        pl.col('HT_PHASOR').struct.field('inphase').alias('HT_PHASOR_inphase'),
+        pl.col('HT_PHASOR').struct.field('quadrature').alias('HT_PHASOR_quadrature'),
+        pl.col('HT_SINE').struct.field('sine').alias('HT_SINE_sine'),
+        pl.col('HT_SINE').struct.field('leadsine').alias('HT_SINE_leadsine'),
+        pl.col('MAMA').struct.field('mama').alias('MAMA_mama'),
+        pl.col('MAMA').struct.field('fama').alias('MAMA_fama'),
+        pl.col('STOCHF').struct.field('fastk').alias('STOCHF_fastk'),
+        pl.col('STOCHF').struct.field('fastd').alias('STOCHF_fastd'),
+        pl.col('STOCHRSI').struct.field('fastk').alias('STOCHRSI_fastk'),
+        pl.col('STOCHRSI').struct.field('fastd').alias('STOCHRSI_fastd'),
+        pl.col('MINMAX_30').struct.field('min').alias('MINMAX_30_min'),
+        pl.col('MINMAX_30').struct.field('max').alias('MINMAX_30_max'),
+        pl.col('MINMAXINDEX_30').struct.field('minidx').alias('MINMAXINDEX_30_minidx'),
+        pl.col('MINMAXINDEX_30').struct.field('maxidx').alias('MINMAXINDEX_30_maxidx'),
+    ])
+    
+    
+    # Drop the original struct columns
+    df_group = df_group.drop(['BBANDS', 'MACD', 'STOCH', 'AROON_14', 'HT_PHASOR', 'HT_SINE','MAMA','STOCHF','MINMAX_30','MINMAXINDEX_30'])
+    
+    return df_group
+
+
+def techn_indicators(df_price):
+    # Assuming df_polars is your initial DataFrame
+    df_polars = pl.from_pandas(df_price.reset_index())
+    df_polars = df_polars.group_by("ticker").map_groups(func_ts_date).to_pandas().set_index(["ticker","date"]).sort_index()
+    
+    # List of columns to remove
+    columns_to_remove = [
+        'OBV', 'AD', 'ADOSC', 'VAR_5', 'TRANGE',
+        'STOCHRSI',
+        'DIV', 'LN', 'LOG10',
+        'COS',
+        'EMA_20', 'MOM_10', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE', 'WCLPRICE',
+        'BETA_5', 'CORREL_30', 'LINEARREG_14', 'TSF_14', 'SAR', 'MAVP', 'SAREXT'
+    ]
+    
+    # Remove problematic columns
+    df_polars = df_polars.drop(columns=[col for col in columns_to_remove if col in df_polars.columns])
+    
+    return df_polars

{sovai-0.2.0 → sovai-0.2.2}/sovai/get_data.py

@@ -21,7 +21,8 @@ import boto3
 from io import BytesIO
 import json
 
-# from fastapi import HTTPException
+# from fastapi import HTTPException ## Dee
+
 import pyarrow.parquet as pq
 import time
 import hashlib
@@ -105,7 +106,104 @@ def read_parquet(
         return pl.read_parquet(url)
     else:
         return CustomDataFrame(pd.read_parquet(url))
+    
 
+import pandas as pd
+from typing import Union, List
+
+def filter_data(
+    data: Union[pd.DataFrame, 'pl.DataFrame'],
+    columns: Union[str, List[str]] = None,
+    start_date: str = None,
+    end_date: str = None,
+    use_polars: bool = False
+) -> Union[pd.DataFrame, 'pl.DataFrame']:
+    """
+    Filter the data based on specified columns and date range.
+    Always includes 'ticker', 'date', and 'calculation' columns if they exist in the original DataFrame.
+    
+    :param data: Input DataFrame (pandas or polars)
+    :param columns: Columns to select (string or list of strings)
+    :param start_date: Start date for filtering (string in 'YYYY-MM-DD' format)
+    :param end_date: End date for filtering (string in 'YYYY-MM-DD' format)
+    :param use_polars: Boolean indicating whether to use polars instead of pandas
+    :return: Filtered DataFrame
+    """
+    if use_polars:
+        import polars as pl
+        
+        # Prepare columns list
+        if columns:
+            if isinstance(columns, str):
+                columns = columns.split(',')
+            columns = [col.strip() for col in columns]
+        else:
+            columns = data.columns.to_list()
+        
+        # Always include 'ticker', 'date', and 'calculation' if they exist
+        for col in ['calculation', 'date', 'ticker']:
+            if col in data.columns and col not in columns:
+                columns.insert(0, col)
+        
+        # Column filtering
+        data = data.select(columns)
+        
+        # Date filtering
+        if start_date or end_date:
+            if 'date' in data.columns:
+                if start_date:
+                    data = data.filter(pl.col('date') >= pl.Date.parse(start_date))
+                if end_date:
+                    data = data.filter(pl.col('date') <= pl.Date.parse(end_date))
+            else:
+                # Assume date is in index if not in columns
+                data = data.with_row_count('temp_index')
+                if start_date:
+                    data = data.filter(pl.col('temp_index').cast(pl.Date) >= pl.Date.parse(start_date))
+                if end_date:
+                    data = data.filter(pl.col('temp_index').cast(pl.Date) <= pl.Date.parse(end_date))
+                data = data.drop('temp_index')
+    
+    else:
+        # Prepare columns list
+        if columns:
+            if isinstance(columns, str):
+                columns = columns.split(',')
+            columns = [col.strip() for col in columns]
+        else:
+            columns = list(data.columns)
+        
+        # Always include 'ticker', 'date', and 'calculation' if they exist
+        for col in ['calculation', 'date', 'ticker']:
+            if col in data.columns and col not in columns:
+                columns.insert(0, col)
+        
+        # Column filtering
+        data = data[columns]
+        
+        if start_date or end_date:
+            if 'date' in data.columns:
+                data['date'] = pd.to_datetime(data['date'])
+                if start_date:
+                    data = data[data['date'] >= pd.to_datetime(start_date)]
+                if end_date:
+                    data = data[data['date'] <= pd.to_datetime(end_date)]
+            elif isinstance(data.index, pd.DatetimeIndex):
+                if start_date:
+                    data = data[data.index >= pd.to_datetime(start_date)]
+                if end_date:
+                    data = data[data.index <= pd.to_datetime(end_date)]
+            elif isinstance(data.index, pd.MultiIndex) and any(isinstance(level, pd.DatetimeIndex) for level in data.index.levels):
+                date_level = next(level for level in data.index.levels if isinstance(level, pd.DatetimeIndex))
+                if start_date:
+                    data = data[data.index.get_level_values(date_level.name) >= pd.to_datetime(start_date)]
+                if end_date:
+                    data = data[data.index.get_level_values(date_level.name) <= pd.to_datetime(end_date)]
+            else:
+                print("Warning: Unable to filter by date. Date column or index not found.")
+    
+    
+    return data
 
 # Global cache
 _query_cache = {}
@@ -115,6 +213,9 @@ _query_cache = {}
 ## None means no ticker. "" Mean ticker but on parquet for all.
 
 endpoint_to_ticker = {
+    "/risks": "",
+    "/government/traffic/domains": "",
+    "/government/traffic/agencies": "",
     "/risks": "",
     "/bankruptcy": "",
     "/bankruptcy/shapleys": "",
@@ -172,7 +273,10 @@ endpoint_to_ticker = {
     "/complaints/public": "",
     "/short/over_shorted": "",
     "/earnings/surprise": "",
-    "/market/closeadj": "",
+    "/news/sentiment_score": "",
+    "/news/topic_probability": "",
+    "/news/polarity_score": "",
+
 }
 
 ## There are give types of file retrievals
@@ -375,17 +479,24 @@ def data(
             _query_cache[cache_key] = data
             return data
 
+ 
+        # Example usage in your existing code:
         if is_all(tickers):
             verbose_mode.vprint("All ticker Initialized")
             url = res.text.strip('"')
             verbose_mode.vprint(url, " (download link)")
             data = read_parquet(url, use_polars=use_polars)
-            _query_cache[cache_key] = data
-            return data
+            
+            # Apply filters
+            data = filter_data(data, columns=columns, start_date=start_date, end_date=end_date, use_polars=use_polars)
 
         verbose_mode.vprint("It reached the DF")
-        data = CustomDataFrame(convert_data2df(res.json()))
-        _query_cache[cache_key] = data
+        try:
+            data = CustomDataFrame(convert_data2df(res.json()))
+            _query_cache[cache_key] = data
+        except:
+            _query_cache[cache_key] = data
+
         verbose_mode.vprint("It passed the DF")
 
         if plot:
@@ -394,6 +505,7 @@ def data(
         return data
     except Exception as err:
         verbose_mode.vprint("An error occurred:", err)
+        return data
         if res.status_code == 404:
             msg = res.json()
             msg.update({"status_code": 404, "error": err.args[0]})
@@ -401,160 +513,6 @@ def data(
     return None
 
 
-# def print_tickers_value(tickers):
-#     if tickers is None:
-#         print("tickers is None")
-#     elif tickers is False:
-#         print("tickers is False")
-#     else:
-#         print(f"tickers is: {tickers}")
-
-# # Example usage
-
-# def data(
-#     endpoint: str,
-#     tickers: Union[str, list, None] = None,
-#     chart: Optional[str] = None,
-#     columns_name: Optional[str] = None,
-#     version: Optional[str] = None,
-#     start_date: Optional[str] = None,
-#     end_date: Optional[str] = None,
-#     predict: bool = False,
-#     plot: bool = False,
-#     rows: Optional[int] = None,
-#     limit: Optional[int] = None,
-#     params: Optional[dict] = None,
-#     body: Optional[dict] = None,
-#     use_polars: bool = False,
-#     purge_cache: bool = False,
-#     parquet: bool = True,
-# ) -> Union[pd.DataFrame, None]:
-#     params = params or {}
-#     params.update(
-#         _prepare_params(
-#             tickers=tickers,
-#             chart=chart,
-#             version=version,
-#             from_date=start_date,
-#             to_date=end_date,
-#             limit=rows or limit,
-#             predict=predict,
-#             columns=columns_name,
-#         )
-#     )
-#     endpoint, params = _prepare_endpoint(endpoint, params)
-#     print(endpoint)
-#     params = params or None
-#     headers = {"Authorization": f"Bearer {ApiConfig.token}"}
-#     url = ApiConfig.base_url + endpoint
-
-#     print(f"Requesting URL: {url} with params: {params}")
-
-# # Create a unique cache key
-#     cache_key = hashlib.sha256(json.dumps([url, params], sort_keys=True).encode()).hexdigest()
-
-#     # Check if the result is already in the cache
-#     # Purge cache if requested
-#     if purge_cache and cache_key in _query_cache:
-#         del _query_cache[cache_key]
-#         print("Cache entry purged.")
-
-#     # Check if the result is already in the cache
-#     if not purge_cache and cache_key in _query_cache:
-#         print("Returning cached data")
-#         return _query_cache[cache_key]
-
-#     try:
-#         res = requests.get(
-#             url=url,
-#             headers=headers,
-#             data=body,
-#             params=params,
-#             stream=True,
-#             verify=ApiConfig.verify_ssl,
-#         )
-#         res.raise_for_status()
-#         print(f"Response Status: {res.status_code}")
-#         print(f"Response Content-Type: {res.headers.get('content-type')}")
-
-#         # Print a small part of the response for preview
-#         # response_preview = res.text[:2]  # Adjust the number of characters as needed
-#         # print(f"Response Preview: {response_preview}")
-#         print_tickers_value(tickers)
-
-#         print(params)
-
-#         # print("Before check..")
-#         # print(is_all(tickers))
-#         # if is_all(tickers):
-#         #     response_dict = res.json()
-#         #     print("this is loading parquet")
-#         #     # Assuming response_dict is a dictionary containing the required keys
-#         #     print("Bucket Name:", response_dict["bucket_name"])
-#         #     print("File Name:", response_dict["file_name"])
-#         #     print("Access Key:", response_dict["access_key"])
-#         #     print("Secret Key:", response_dict["secret_key"])
-
-#         #     return load_df_from_wasabi(response_dict["bucket_name"], response_dict["file_name"], response_dict["access_key"], response_dict["secret_key"])
-
-#         tickers = get_ticker_from_endpoint(endpoint, tickers, endpoint_to_ticker)
-
-#         print_tickers_value(tickers)
-
-
-#         data_format = res.headers.get("X-Data-Format")
-#         content_type = res.headers["content-type"]
-
-#         if content_type == "application/octet-stream":
-#             if data_format == "pyarrow":
-#                 data = CustomDataFrame(stream_data_pyarrow(res))
-#             else:
-#                 data = CustomDataFrame(stream_data(res))
-#             _query_cache[cache_key] = data
-#             return data
-
-
-#         if is_all(tickers):
-#             print("All ticker Initialized")
-#             url = res.text.strip('"')
-#             print(url, " (download link)", )
-#             data = read_parquet(url, use_polars=use_polars)
-#             _query_cache[cache_key] = data
-
-#             return data
-
-
-#         print("It reached the DF")
-#         data = CustomDataFrame(convert_data2df(res.json()))
-#         _query_cache[cache_key] = data
-#         print("It passsed the DF")
-
-#         if plot:
-#             _draw_graphs(data)
-#             return None
-#         return data
-#     except Exception as err:
-#         print("An error occurred:", err)
-#         if res.status_code == 404:
-#             msg = res.json()
-#             msg.update({"status_code": 404, "error": err.args[0]})
-#             raise InvalidInputData(str(msg))
-#     return None
-
-
-# def _prepare_params(**kwargs):
-#     finish_params = {}
-#     if isinstance(kwargs["tickers"], list):
-#         kwargs["tickers"] = ",".join(kwargs["tickers"])
-#     if isinstance(kwargs["columns"], list):
-#         kwargs["columns"] = ",".join(kwargs["columns"])
-#     for server_param, client_param in kwargs.items():
-#         if client_param:
-#             finish_params[server_param] = str(client_param)
-
-#     return finish_params
-
-
 def _prepare_params(**kwargs):
     finish_params = {}
 

{sovai-0.2.0 → sovai-0.2.2}/sovai/get_plots.py

@@ -5,11 +5,12 @@ from .plots.breakout.breakout_plots import *
 from .plots.accounting.accounting_plots import *
 from .plots.ratios.ratios_plots import *
 from .plots.institutional.institutional_plots import *
-from .plots.news.news_plots import *
+from .plots.news.news_plots import plot_news_daily, create_plot_news_sent_price, plot_above_sentiment_returns, run_dash_news_ts
 from .plots.corp_risk.corp_risk_plots import *
 
 from .plots.insider.insider_plots import *
 from .plots.allocation.allocation_plots import *
+from .plots.earnings_surprise.earnings_surprise_plots import *
 
 from sovai.utils.plot import plotting_data
 from typing import Optional, Union, Tuple, List, Dict
@@ -70,6 +71,7 @@ def generate_error_message(analysis_type, chart_type, source, verbose):
     else:
         display(Markdown("**An unknown error occurred.**"))
 
+## 
 
 plot_ticker_widget
 
@@ -110,9 +112,15 @@ PLOT_FUNCTION_MAPPER = {
     ("insider", "flows", "local"): insider_flows_plot,
     ("insider", "prediction", "local"): insider_flow_predictions_plot,
     ("news", "sentiment", "local"): plot_above_sentiment_returns,
+    ("news", "strategy", "local"): plot_news_daily,
+    ("news", "analysis", "local"): run_dash_news_ts,
     ("corprisk/risks", "line", "local"): plotting_corp_risk_line,
     ("allocation", "line", "local"): create_line_plot_allocation,
     ("allocation", "stacked", "local"): create_stacked_bar_plot_allocation,
+    ("earnings", "line", "local"): create_earnings_surprise_plot,
+
+
+    
 
     # Add other mappings as needed
 }
@@ -120,7 +128,7 @@ PLOT_FUNCTION_MAPPER = {
 
 def plot(
     dataset_name,
-    chart_type="line",
+    chart_type=None,
     df=None,
     tickers: Optional[List[str]] = None,
     verbose=False,