sovai 0.2.65__tar.gz → 0.2.67__tar.gz

{sovai-0.2.65 → sovai-0.2.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sovai
-Version: 0.2.65
+Version: 0.2.67
 Summary: python for asset management
 License: Proprietary License
 Author: Derek Snow

{sovai-0.2.65 → sovai-0.2.67}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sovai"
-version = "0.2.65"
+version = "0.2.67"
 description = "python for asset management"
 authors = [
     {name = "Derek Snow", email = "d.snow@outlook.com"}

{sovai-0.2.65 → sovai-0.2.67}/sovai/get_data.py

@@ -493,7 +493,14 @@ ENDPOINT_ALIASES = {
             'trial_id', 'official_title', 'success_prediction', 
             'economic_effect', 'duration_prediction', 'success_composite'
         ]
+    },
+    "insider/flow_prediction": {
+        "target_endpoint": "insider/trading",
+        "columns": [
+            'flow_prediction'
+        ]
     }
+
     # --- Add other aliases here in the future ---
     # "some/alias": {
     #     "target_endpoint": "real/endpoint",
@@ -502,6 +509,8 @@ ENDPOINT_ALIASES = {
 }
 
 
+
+
 # Define handlers for different endpoint types
 ENDPOINT_HANDLERS = [
    (CLIENT_SIDE_ENDPOINTS_GCS, client_side_frame, "Grabbing GCS client side"),

sovai-0.2.67/sovai/get_plots.py

@@ -0,0 +1,362 @@
+# Inside plot/get_plot.py
+import inspect # Still useful for one specific check
+
+# --- Top Level Imports (Keep lightweight) ---
+from typing import Optional, Union, Tuple, List, Dict
+import importlib # Needed for dynamic imports
+# Keep pandas/plotly config at top level as they modify global state
+import pandas as pd
+import plotly.io as pio
+
+# --- Global Settings ---
+# Changing the default plotting backend to Plotly
+# Ensure pandas is imported before using pd.options
+pd.options.plotting.backend = "plotly"
+pd.set_option("display.max_columns", None)
+# Setting the default theme for Plotly to a dark mode
+pio.templates.default = "plotly_dark"
+
+
+# --- Helper Functions (Potentially moved or kept if simple) ---
+
+def enable_plotly_in_cell():
+    # Lazy load IPython and plotly offline here
+    try:
+        import IPython
+        from IPython.display import display, HTML
+        from plotly.offline import init_notebook_mode
+
+        display(
+            HTML(
+                """<script src="/static/components/requirejs/require.js"></script>"""
+            )
+        )
+        init_notebook_mode(connected=False)
+    except ImportError:
+        print("Warning: IPython or plotly offline not available. Plotly may not render correctly in this environment.")
+
+
+def _draw_graphs(data: Union[Dict, List[Dict]]):
+    """Helper to draw graphs from database results (if structure is consistent)."""
+    # Lazy load the actual plotting utility if needed
+    from sovai.utils.plot import plotting_data # Assuming this utility exists
+    if isinstance(data, list):
+        for plot_dict in data:
+             if isinstance(plot_dict, dict):
+                  for _, val in plot_dict.items():
+                      return plotting_data(val) # Plot first one found
+    elif isinstance(data, dict):
+        for _, val in data.items():
+            return plotting_data(val) # Plot first one found
+    else:
+         print(f"Warning: _draw_graphs received unexpected data type: {type(data)}")
+         return None
+
+
+def generate_error_message(analysis_type, chart_type, source, verbose):
+    """Generates error message, potentially displaying Markdown."""
+    try:
+         from IPython.display import display, Markdown
+         if source == "local":
+             code_snippet = (
+                 f"# Ensure sovai is imported, e.g., import sovai as sov\n"
+                 f"dataset = sov.data('{analysis_type}/monthly') # Or appropriate frequency\n"
+                 f"if dataset is not None and not dataset.empty:\n"
+                 f"    sov.plot('{analysis_type}', chart_type='{chart_type}', df=dataset)\n"
+                 f"else:\n"
+                 f"    print('Failed to fetch data.')"
+             )
+             message = (
+                 f"**Input DataFrame `df` is empty or None.** Please provide a valid DataFrame.\n"
+                 f"If you intended to fetch data first, you could use:\n\n"
+                 f"```python\n{code_snippet}\n```"
+             )
+             if verbose: # Only display if verbose is True
+                 display(Markdown(message))
+             return "" # Return empty string as add_text no longer used this way
+         else:
+             display(Markdown("**An unknown error occurred.**")) # This part might be too generic
+             return ""
+    except ImportError:
+         # Fallback for non-IPython environments
+         text_message = ""
+         if source == "local":
+              text_message = f"Input DataFrame `df` is empty or None. Please fetch data first (e.g., using sov.data(...))."
+         else:
+              text_message = "An unknown error occurred."
+         if verbose: # Print simple text if verbose and IPython not available
+             print(text_message)
+         return ""
+
+
+# --- Plot Function Mapper ---
+PLOT_FUNCTION_MAPPER = {
+    # (dataset_name, chart_type, source, full_history_flag_or_None) : (module_path, function_name)
+    ("breakout", "predictions", "local", True): (".plots.breakout.breakout_plots", "get_predict_breakout_plot_for_ticker"),
+    ("breakout", "accuracy", "local", True): (".plots.breakout.breakout_plots", "interactive_plot_display_breakout_accuracy"),
+    ("accounting/weekly", "balance", "local", False): (".plots.accounting.accounting_plots", "get_balance_sheet_tree_plot_for_ticker"),
+    ("accounting", "cashflows", "local", True): (".plots.accounting.accounting_plots", "plot_cash_flows"),
+    ("accounting", "assets", "local", True): (".plots.accounting.accounting_plots", "plot_assets"),
+    ("ratios", "relative", "local", True): (".plots.ratios.ratios_plots", "plot_ratios_triple"),
+    ("ratios", "benchmark", "local", True): (".plots.ratios.ratios_plots", "plot_ratios_benchmark"),
+    ("institutional", "flows", "local", True): (".plots.institutional.institutional_plots", "institutional_flows_plot"),
+    ("institutional", "prediction", "local", True): (".plots.institutional.institutional_plots", "institutional_flow_predictions_plot"),
+    ("insider", "percentile", "local", True): (".plots.insider.insider_plots", "create_parallel_coordinates_plot_single_ticker"),
+    ("insider", "flows", "local", True): (".plots.insider.insider_plots", "insider_flows_plot"),
+    ("insider", "prediction", "local", True): (".plots.insider.insider_plots", "insider_flow_predictions_plot"),
+    ("news", "sentiment", "local", True): (".plots.news.news_plots", "plot_above_sentiment_returns"),
+    ("news", "strategy", "local", True): (".plots.news.news_plots", "plot_news_daily"),
+    ("news", "analysis", "local", True): (".plots.news.news_plots", "run_dash_news_ts"),
+    ("corprisk/risks", "line", "local", True): (".plots.corp_risk.corp_risk_plots", "plotting_corp_risk_line"),
+    ("allocation", "line", "local", True): (".plots.allocation.allocation_plots", "create_line_plot_allocation"),
+    ("allocation", "stacked", "local", True): (".plots.allocation.allocation_plots", "create_stacked_bar_plot_allocation"),
+    ("earnings/surprise", "line", "local", True): (".plots.earnings_surprise.earnings_surprise_plots", "create_earnings_surprise_plot"),
+    ("earnings/surprise", "tree", "local", True): (".plots.earnings_surprise.earnings_surprise_plots", "earnings_tree"),
+    ("bankruptcy", "compare", "local", True): (".plots.bankruptcy.bankruptcy_plots", "plot_bankruptcy_monthly_line"),
+    ("bankruptcy", "pca_clusters", "local", True): (".plots.bankruptcy.bankruptcy_plots", "plot_pca_clusters"),
+    ("bankruptcy", "predictions", "local", True): (".plots.bankruptcy.bankruptcy_plots", "plot_ticker_widget"),
+
+    # Database plots use the local _draw_graphs helper
+    ("bankruptcy", "shapley", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "pca", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "line", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "similar", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "facet", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "stack", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "box", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "waterfall", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "pca_relation", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "line_relation", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "facet_relation", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "time_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "stack_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "box_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "waterfall_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "confusion_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "classification_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "precision_global", "database"): (None, "_draw_graphs"),
+    ("bankruptcy", "lift_global", "database"): (None, "_draw_graphs"),
+}
+
+
+# --- Main Plot Function ---
+
+def plot(
+    dataset_name,
+    chart_type=None,
+    df=None,
+    tickers: Optional[List[str]] = None,
+    ticker: Optional[str] = None,
+    verbose=False,
+    purge_cache=False,
+    **kwargs, # These are kwargs passed to the main sov.plot() call
+):
+    """
+    Generates plots based on dataset name and chart type.
+    Lazily loads required plotting modules.
+    """
+    from sovai import data as sovai_data
+
+    # Consolidate ticker/tickers from sov.plot() into lookup_tickers for sovai_data
+    # and also ensure they are present in kwargs for the plot_function if needed.
+    if ticker is not None:
+        if isinstance(ticker, str):
+            lookup_tickers = [ticker]
+            kwargs['ticker'] = ticker # Ensure 'ticker' is in kwargs for plot_func
+        elif isinstance(ticker, list):
+            lookup_tickers = ticker
+            if len(ticker) == 1: # If plot_func expects single 'ticker'
+                 kwargs['ticker'] = ticker[0]
+            # If plot_func expects 'tickers' (list), it should already be in kwargs if passed as 'tickers='
+        else: # Should not happen
+            lookup_tickers = None
+    elif tickers is not None:
+        if isinstance(tickers, str):
+            lookup_tickers = [tickers]
+            kwargs['tickers'] = [tickers] # Ensure 'tickers' list is in kwargs
+        elif isinstance(tickers, list):
+            lookup_tickers = tickers
+            kwargs['tickers'] = tickers
+        else: # Should not happen
+            lookup_tickers = None
+    else:
+        lookup_tickers = None
+    
+    enable_plotly_in_cell()
+
+    plot_info = None; source = None; full_history = None
+    key_local_4 = (dataset_name, chart_type, "local", True)
+    key_local_3 = (dataset_name, chart_type, "local", False)
+    key_db_3 = (dataset_name, chart_type, "database")
+
+    if key_local_4 in PLOT_FUNCTION_MAPPER:
+        source = "local"; full_history = True; plot_info = PLOT_FUNCTION_MAPPER[key_local_4]
+    elif key_local_3 in PLOT_FUNCTION_MAPPER:
+         source = "local"; full_history = False; plot_info = PLOT_FUNCTION_MAPPER[key_local_3]
+    elif key_db_3 in PLOT_FUNCTION_MAPPER:
+        source = "database"; plot_info = PLOT_FUNCTION_MAPPER[key_db_3]
+    else:
+         key_local_any_hist = (dataset_name, chart_type, "local")
+         possible_keys = [k for k in PLOT_FUNCTION_MAPPER if k[:3] == key_local_any_hist]
+         if possible_keys:
+              matched_key = possible_keys[0]
+              source = "local"; full_history = matched_key[3]; plot_info = PLOT_FUNCTION_MAPPER[matched_key]
+         else:
+              raise ValueError(f"Plotting function for dataset='{dataset_name}' with chart_type='{chart_type}' not found.")
+
+    module_path, function_name = plot_info
+
+    plot_function = None
+    if module_path:
+        try:
+            imported_module = importlib.import_module(module_path, package=__package__)
+            plot_function = getattr(imported_module, function_name)
+        except ImportError as e:
+            raise ImportError(f"Could not import plotting module '{module_path}' relative to {__package__}: {e}")
+        except AttributeError:
+            raise AttributeError(f"Function '{function_name}' not found in module '{module_path}'.")
+    elif function_name == "_draw_graphs":
+        plot_function = _draw_graphs
+    else:
+         raise ValueError(f"Invalid plot_info found in mapper: {plot_info} for {dataset_name}, {chart_type}")
+
+    if source == "local":
+        data_to_plot = df # User-provided DataFrame
+        
+        # --- Conditional Data Fetching ---
+        # Check if the plot function seems to handle its own data via 'ticker' or 'tickers' params
+        # and if it doesn't explicitly take 'df' or a generic first positional for data.
+        skip_prefetch = False
+        try:
+            sig = inspect.signature(plot_function)
+            param_names = set(sig.parameters.keys())
+            # Heuristic: if it takes 'ticker' or 'tickers' but NOT 'df' or 'data' (common df names)
+            # AND doesn't seem to take a generic first positional argument for data (e.g. only has keyword args)
+            has_ticker_arg = 'ticker' in param_names or 'tickers' in param_names
+            has_df_arg = 'df' in param_names or 'data' in param_names or 'data_df' in param_names
+            
+            first_param = next(iter(sig.parameters.values()), None)
+            is_first_pos_for_data = first_param and \
+                                    (first_param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD or \
+                                     first_param.kind == inspect.Parameter.POSITIONAL_ONLY) and \
+                                    first_param.name not in ('ticker', 'tickers') # Not 'ticker' itself
+
+            if has_ticker_arg and not has_df_arg and not is_first_pos_for_data :
+                skip_prefetch = True
+                if verbose: print(f"Plot function '{function_name}' seems to manage its own data via ticker/tickers; skipping dispatcher prefetch.")
+        except ValueError: # Built-in functions might not have inspectable signatures
+            pass # Proceed with default prefetch
+
+        if not skip_prefetch and (data_to_plot is None or data_to_plot.empty):
+            if verbose:
+                generate_error_message(dataset_name, chart_type, source, verbose)
+                print(f"Attempting to fetch data for {dataset_name} (tickers: {lookup_tickers}, full_history: {full_history})...")
+            try:
+                 fetched_data = sovai_data(dataset_name, tickers=lookup_tickers, full_history=full_history)
+                 if fetched_data is not None and not fetched_data.empty:
+                     data_to_plot = fetched_data
+                     if verbose: print(f"Successfully fetched data for {dataset_name}.")
+                 else:
+                     if verbose: print(f"Failed to fetch data or fetched empty data for {dataset_name}.")
+            except Exception as e:
+                 if verbose: print(f"Error fetching data for {dataset_name}: {e}")
+        
+        # --- Call plot function with refined try-except ---
+        try:
+            if verbose: print(f"Calling plot function '{function_name}'.")
+            return plot_function(data_to_plot, **kwargs)
+        except TypeError as te:
+            # Handle 0-argument function error
+            is_zero_arg_error = (
+                "takes 0 positional arguments" in str(te) and
+                "1 was given" in str(te)
+            )
+            if is_zero_arg_error:
+                if verbose: print(f"TypeError (0-arg): Retrying {function_name} with only kwargs.")
+                try:
+                    return plot_function(**kwargs) # Retry with only kwargs
+                except Exception as e_fallback:
+                    print(f"Original TypeError (0-arg) with {function_name}: {te}")
+                    print(f"Error in 0-arg fallback for '{function_name}': {e_fallback}")
+                    raise e_fallback
+            
+            # Handle case where plot_function expects specific kwargs (like 'ticker')
+            # but received data_to_plot as an unwanted positional argument.
+            # This often happens if plot_function is like `def func(ticker=None):`
+            # and was called as `func(data_frame, ticker='val')`
+            else:
+                try:
+                    sig = inspect.signature(plot_function)
+                    # Filter kwargs to only those accepted by plot_function
+                    accepted_kwargs = {
+                        k: v for k, v in kwargs.items() 
+                        if k in sig.parameters or \
+                           any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values())
+                    }
+                    # If data_to_plot was non-None and function has no clear positional data param,
+                    # it might be the cause of the TypeError. Try without it.
+                    
+                    # Heuristic: Does the function primarily expect keyword args like 'ticker'?
+                    # And does not seem to want data_to_plot positionally?
+                    param_names = set(sig.parameters.keys())
+                    first_param = next(iter(sig.parameters.values()), None)
+                    takes_pos_data = first_param and \
+                                     (first_param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD or \
+                                      first_param.kind == inspect.Parameter.POSITIONAL_ONLY) and \
+                                     first_param.name not in ('ticker', 'tickers') # and not 'df', 'data' etc.
+
+                    if not takes_pos_data and ('ticker' in param_names or 'tickers' in param_names):
+                        if verbose: print(f"TypeError (kwarg-focused func): Retrying {function_name} with accepted kwargs, no positional data.")
+                        return plot_function(**accepted_kwargs)
+                    else:
+                        # Original TypeError was likely valid for other reasons
+                        print(f"TypeError calling plot function '{function_name}': {te}. Args: {data_to_plot}, Kwargs: {kwargs}")
+                        raise te
+                except Exception as e_inspect_fallback:
+                    # If inspection or second attempt itself fails, raise original TypeError
+                    print(f"Error during TypeError fallback for {function_name}: {e_inspect_fallback}")
+                    print(f"Original TypeError calling plot function '{function_name}': {te}. Args: {data_to_plot}, Kwargs: {kwargs}")
+                    raise te from None # Raise original te, suppress context from e_inspect_fallback
+        except Exception as e:
+            print(f"An unexpected error occurred while calling plot function '{function_name}': {e}")
+            raise e
+    elif source == "database":
+        try:
+            datasets = sovai_data(
+                dataset_name + "/charts",
+                chart=chart_type,
+                tickers=lookup_tickers,
+                purge_cache=purge_cache,
+                **kwargs,
+            )
+        except Exception as e:
+             if verbose: print(f"Error fetching database chart data for {dataset_name}: {e}")
+             return None
+
+        if datasets is None:
+            if verbose: print(f"Failed to retrieve data for {dataset_name}/charts with chart type {chart_type} and tickers {lookup_tickers}")
+            return None
+
+        try:
+            if isinstance(datasets, list):
+                 if plot_function == _draw_graphs:
+                      for dataset_item in datasets:
+                           if dataset_item is not None:
+                                fig = plot_function(dataset_item, **kwargs)
+                                if fig: return fig
+                      if verbose: print("No plottable data found in the list of datasets for _draw_graphs.")
+                      return None
+                 else:
+                      if verbose: print("Warning: Received a list of datasets for database source, plotting first non-None item.")
+                      for dataset_item in datasets:
+                          if dataset_item is not None:
+                              return plot_function(dataset_item, **kwargs)
+                      if verbose: print("No non-None dataset found in the list to plot.")
+                      return None
+            else:
+                 return plot_function(datasets, **kwargs)
+        except Exception as e:
+             print(f"Error calling plot function '{function_name}' for database data: {e}")
+             raise e
+    else:
+        raise ValueError(f"Source '{source}' derived from mapper is not recognized.")

{sovai-0.2.65 → sovai-0.2.67}/sovai/get_reports.py

@@ -75,32 +75,43 @@ def report(dataset_name, report_type="sector-top", **kwargs):
 
     df = kwargs.get("df")
     if df is None:
+        # If df is not provided, try to fetch it.
+        # Crucially, pass along **kwargs from the report() call to data().
         try:
             if report_type == "ranking":
-                df = data(dataset_name, frequency="latest")
+                df = data(dataset_name, frequency="latest", **kwargs)
             elif report_type == "change":
-                print("change")
-                df = data(dataset_name, frequency="difference")
+                # print("change") # Consider using logging instead of print
+                df = data(dataset_name, frequency="difference", **kwargs)
             elif report_type == "previous":
-                df = data(dataset_name, frequency="previous")
+                df = data(dataset_name, frequency="previous", **kwargs)
             else:
-                df = data(dataset_name)
-        except:
-            try:
-                df = data(dataset_name)
-            except:
-                return report_function(*additional_args, **kwargs)
+                # This case applies to ("accounting", "balance_sheet")
+                # dataset_name will be "accounting"
+                # **kwargs will include {'ticker': 'MSFT'}
+                df = data(dataset_name, **kwargs) 
+        except Exception as e_fetch:
+            # Handle cases where data fetching might fail.
+            # For reports like jupyter_html_assets that fetch their own data,
+            # this 'df' might not be strictly necessary.
+            print(f"Warning: Initial data fetch for report {dataset_name}/{report_type} failed. Error: {e_fetch}")
+            df = None # Set df to None if fetching fails
 
-    # Use the correct report function based on the report type
-    if report_type == "change":
-        return general_ranking_change(df, *additional_args, **kwargs)
-    elif report_type in ["ranking", "previous"]:
-        return general_ranking(df, *additional_args, **kwargs)
+    # Decide how to call the actual report-generating function
+    if report_function in [jupyter_html_assets,create_interactive_report]:
+        # jupyter_html_assets expects 'ticker' from kwargs and fetches its own data.
+        # It does not use the 'df' fetched above.
+        return report_function(**kwargs)
+    # Add elif for other specific report functions if they have unique calling patterns
+    # elif report_function is some_other_report_function_expecting_only_kwargs:
+    #     return report_function(**kwargs)
     else:
+        # Default assumption: the report function takes 'df' as its first argument.
+        # If df is None (due to fetch failure or if it was initially None and not fetched),
+        # it's passed as None, and the report_function must handle it.
         return report_function(df, *additional_args, **kwargs)
 
 
-
 # def report(dataset_name, report_type="sector-top", **kwargs):
 #     # Extract the DataFrame from kwargs
 #     df = kwargs.get('df')

{sovai-0.2.65 → sovai-0.2.67}/sovai/plots/accounting/accounting_plots.py

@@ -18,10 +18,10 @@ import random
 from sovai.utils.port_manager import get_unique_port
 
 
-def get_balance_sheet_tree_plot_for_ticker(df_accounting=None, tickers="MSFT"):
+def get_balance_sheet_tree_plot_for_ticker(df_accounting=None, ticker="MSFT"):
     # Assuming df_accounting is your DataFrame
     if df_accounting is None:
-        df_accounting = data("accounting/weekly", tickers=tickers)
+        df_accounting = data("accounting/weekly", tickers=ticker)
 
     selected_data = df_accounting.iloc[-1]
 
@@ -124,6 +124,7 @@ def get_balance_sheet_tree_plot_for_ticker(df_accounting=None, tickers="MSFT"):
         {
             "level_1": "Total Liabilities & Equity",
             "level_2": "Total Equity",
+            "level_3": "Total Equity",
             "value": selected_data["equity_usd"],
         },
         {

{sovai-0.2.65 → sovai-0.2.67}/sovai/plots/news/news_plots.py

@@ -476,6 +476,8 @@ def create_plot(df, ticker, column, long_ma, short_ma, threshold, future_days):
 
 def plot_news_daily(ticker='NVDA'):
     # Fetch and prepare data
+
+    print(ticker)
     df = fetch_and_prepare_data(ticker, ['tone', 'sentiment'])
 
     # Initialize the Dash app
@@ -778,9 +780,9 @@ def dash_news_ts_analysis(df_sentiment, df_polarity, df_topic):
 
 def run_dash_news_ts():
 
-    df_sentiment = data("news/sentiment_score", full_history=True)
-    df_polarity = data("news/polarity_score", full_history=True)
-    df_topic = data("news/topic_probability", full_history=True)
+    df_sentiment = data("news/sentiment_score", full_history=True).reset_index()
+    df_polarity = data("news/polarity_score", full_history=True).reset_index()
+    df_topic = data("news/topic_probability", full_history=True).reset_index()
 
     app = dash_news_ts_analysis(df_sentiment, df_polarity, df_topic)
     app.run_server(debug=False, port=get_unique_port("news_topic_valuest"), jupyter_mode="inline", jupyter_height=1300)