mainsequence 2.0.0__py3-none-any.whl

mainsequence/virtualfundbuilder/contrib/apps/news_app.py

@@ -0,0 +1,437 @@
+#!/usr/bin/env python3
+import os
+import base64
+from io import BytesIO
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+
+import pandas as pd
+import plotly.graph_objs as go
+from mainsequence.virtualfundbuilder.utils import get_vfb_logger
+
+# Assuming TDAGAgent is correctly set up and accessible in the execution environment
+from mainsequence.virtualfundbuilder.agent_interface import TDAGAgent
+from pydantic import BaseModel, Field
+from polygon import RESTClient
+from jinja2 import Environment, FileSystemLoader
+
+from mainsequence.client import AssetCategory
+from mainsequence.client.models_tdag import Artifact
+from mainsequence.virtualfundbuilder.resource_factory.app_factory import BaseApp, register_app
+
+logger = get_vfb_logger()
+
+POLYGON_API_KEY = os.getenv("POLYGON_API_KEY")
+
+class SentimentReportConfig(BaseModel):
+    """Pydantic model defining parameters for the Sentiment Report."""
+    asset_category_unique_identifier: str = "magnificent_7"
+    report_days: int = 14
+    report_title: str = "Multi-Ticker News Sentiment & Headlines Report"
+    bucket_name: str = "SentimentReports" # Optional: For artifact storage
+    authors: str = "Automated Analysis (Main Sequence AI)"
+    sector: str = "Technology Focus"
+    region: str = "Global"
+    news_items_per_day_limit: int = 5
+    report_id: Optional[str] = "MS_SentimentReport"
+
+@register_app()
+class SentimentReport(BaseApp):
+    """
+    Generates an HTML report summarizing news sentiment and headlines
+    for a list of stock tickers using data from Polygon.io.
+    Additionally, fetches the first 100 words of each article (if possible)
+    and generates a single combined summary displayed below the combined chart.
+    """
+    configuration_class = SentimentReportConfig
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if not POLYGON_API_KEY:
+            raise ValueError("Warning: POLYGON_API_KEY environment variable not set. Data fetching will fail.")
+
+        self.tdag_agent = TDAGAgent()
+
+        logger.info(f"Initializing Sentiment Report with configuration {self.configuration.model_dump()}")
+
+        end_date_dt = datetime.now()
+        start_date_dt = end_date_dt - timedelta(days=self.configuration.report_days -1)
+        self.start_date = start_date_dt.strftime("%Y-%m-%d")
+        self.end_date = end_date_dt.strftime("%Y-%m-%d")
+
+        category = AssetCategory.get(unique_identifier=self.configuration.asset_category_unique_identifier)
+        self.tickers = [a.ticker for a in category.get_assets()]
+        self.category_name = category.display_name
+
+        # Initialize Polygon client once if API key exists
+        self.polygon_client = RESTClient(POLYGON_API_KEY) if POLYGON_API_KEY else None
+
+        # Setup Jinja2 environment once
+        self._setup_jinja()
+
+    def _setup_jinja(self):
+        """Initializes the Jinja2 environment."""
+        template_dir = os.path.join(os.path.dirname(__file__), "templates")
+        if not os.path.isdir(template_dir):
+            raise FileNotFoundError(f"Jinja2 template directory not found: {template_dir}")
+        report_template_path = os.path.join(template_dir, "report.html")
+        if not os.path.isfile(report_template_path):
+            raise FileNotFoundError(f"Jinja2 report template not found: {report_template_path}")
+        self.jinja_env = Environment(loader=FileSystemLoader(template_dir), autoescape=True)
+
+    def _fetch_data(self) -> (Dict[str, pd.DataFrame], Dict[str, Dict[str, List[Dict]]]):
+        """
+        Fetches sentiment counts and news headlines for configured tickers and date range.
+        Returns:
+            Tuple[Dict[str, pd.DataFrame], Dict[str, Dict[str, List[Dict]]]]:
+                - Sentiment data per ticker (date-indexed DataFrame).
+                - News items (title, url) per ticker per date.
+        """
+        if not self.polygon_client:
+            logger.info("Error: Polygon API key not configured. Cannot fetch data.")
+            empty_sentiment = {ticker: pd.DataFrame() for ticker in self.tickers}
+            empty_news = {ticker: {} for ticker in self.tickers}
+            return empty_sentiment, empty_news
+
+        tickers = self.tickers
+        start_date = self.start_date
+        end_date = self.end_date
+
+        results = {}
+        all_news = {}
+        date_range = pd.date_range(start=start_date, end=end_date)
+
+        logger.info(f"Fetching data for tickers: {tickers} from {start_date} to {end_date}")
+
+        for ticker in tickers:
+            logger.info(f" -> Fetching for {ticker}...")
+            sentiment_count = []
+            ticker_news_by_date = {}
+
+            for day in date_range:
+                day_str = day.strftime("%Y-%m-%d")
+                try:
+                    # Fetch news for the day
+                    daily_news_response = list(
+                        self.polygon_client.list_ticker_news(
+                            ticker=ticker, published_utc=day_str, limit=100 # Limit news fetched per day
+                        )
+                    )
+                except Exception as e:
+                    logger.info(f"    Error fetching news for {ticker} on {day_str}: {e}")
+                    daily_news_response = []
+
+                daily_sentiment = {"date": day, "positive": 0, "negative": 0, "neutral": 0}
+                daily_news_items_for_report = []  # Store dicts with 'title' & 'url'
+
+                for article in daily_news_response:
+                    # Extract headline and URL for the report list
+                    if hasattr(article, 'title') and hasattr(article, 'article_url'):
+                        daily_news_items_for_report.append({'title': article.title, 'url': article.article_url})
+
+                    # Extract sentiment from insights
+                    if hasattr(article, "insights") and article.insights:
+                        for insight in article.insights:
+                            if hasattr(insight, 'sentiment'):
+                                sentiment = insight.sentiment
+                                if sentiment == "positive": daily_sentiment["positive"] += 1
+                                elif sentiment == "negative": daily_sentiment["negative"] += 1
+                                elif sentiment == "neutral":  daily_sentiment["neutral"] += 1
+
+                sentiment_count.append(daily_sentiment)
+
+                if daily_news_items_for_report:
+                    ticker_news_by_date[day_str] = daily_news_items_for_report
+
+            # Prepare the sentiment DataFrame for this ticker
+            if sentiment_count:
+                df_sentiment = pd.DataFrame(sentiment_count)
+                df_sentiment["date"] = pd.to_datetime(df_sentiment["date"])
+                df_sentiment.set_index("date", inplace=True)
+                # Ensure all dates in the range are present
+                df_sentiment = df_sentiment.reindex(date_range, fill_value=0)
+                results[ticker] = df_sentiment
+                all_news[ticker] = ticker_news_by_date
+            else:
+                # No sentiment data found
+                logger.info(f"    No sentiment data found for {ticker} in the date range.")
+                results[ticker] = pd.DataFrame(index=date_range, columns=['positive','negative','neutral']).fillna(0)
+                all_news[ticker] = {}
+
+        return results, all_news
+
+    def _download_article_previews(self, all_news_data, words_per_article=50, articles_per_day=2):
+        from newspaper import Article
+
+        article_snippets = []
+        if self.polygon_client and Article is not None:
+            logger.info("\nGathering first 50 words from each article...")
+            for ticker, date_dict in all_news_data.items():
+                for date_str, articles in date_dict.items():
+                    # restrict to 2 items per day
+                    for article_info in articles[:articles_per_day]:
+                        url = article_info.get('url')
+                        if not url:
+                            continue
+                        try:
+                            art = Article(url)
+                            art.download()
+                            art.parse()
+                            # Grab first 100 words
+                            words = art.text.split()
+                            snippet = " ".join(words[:words_per_article])
+                            if snippet:
+                                article_snippets.append(snippet)
+                        except Exception as e:
+                            logger.info(f"    Could not retrieve/parse text from {url} for {ticker} due to: {e}")
+        else:
+            logger.info("\nSkipping article text retrieval (Polygon client or newspaper not available).")
+
+        return article_snippets
+
+    def _generate_plot(self, df_sentiment: pd.DataFrame, chart_title: str) -> Optional[str]:
+        """
+        Generates a Plotly sentiment chart and returns it as a Base64 encoded PNG string.
+        Returns None if no data to plot or if image generation fails.
+        """
+        if df_sentiment.empty or (df_sentiment[['positive','negative','neutral']].sum().sum() == 0):
+            logger.info(f"    No data to plot for '{chart_title}'. Skipping chart generation.")
+            return None
+
+        x_axis_data = df_sentiment.index.to_pydatetime()
+
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=x_axis_data, y=df_sentiment["positive"],
+            mode="lines+markers", name="Positive",
+            line=dict(color="green"), marker=dict(size=5))
+        )
+        fig.add_trace(go.Scatter(
+            x=x_axis_data, y=df_sentiment["negative"],
+            mode="lines+markers", name="Negative",
+            line=dict(color="red"), marker=dict(size=5))
+        )
+        fig.add_trace(go.Scatter(
+            x=x_axis_data, y=df_sentiment["neutral"],
+            mode="lines+markers", name="Neutral",
+            line=dict(color="gray", dash="dash"), marker=dict(size=5))
+        )
+
+        fig.update_layout(
+            title=f"{chart_title} News Sentiment Over Time",
+            xaxis_title="Date", yaxis_title="Sentiment Count", legend_title="Sentiment",
+            width=850, height=450, margin=dict(l=40, r=40, t=60, b=40),
+            xaxis=dict(
+                type='date',
+                tickformat="%Y-%m-%d"
+            )
+        )
+
+        buf = BytesIO()
+        try:
+            fig.write_image(buf, format="png", scale=2)
+            buf.seek(0)
+            encoded_plot = base64.b64encode(buf.read()).decode("utf-8")
+            return encoded_plot
+        except Exception as e:
+            logger.info(f"    Error generating PNG for '{chart_title}': {e}")
+            return None
+
+
+    def _format_ticker_sections(self, all_sentiment_data, all_news_data):
+        ticker_sections_html = ""
+        logger.info("\nGenerating individual ticker sections...")
+        for ticker in self.tickers:
+            df_sentiment = all_sentiment_data.get(ticker)
+            ticker_news = all_news_data.get(ticker, {})
+            ticker_html = f"<h2>{ticker} Sentiment & News</h2>\n"
+            logger.info(f" -> Processing {ticker}")
+
+            # Plot for this ticker
+            chart_base64 = self._generate_plot(df_sentiment, ticker)
+            if chart_base64:
+                ticker_html += f"""
+                     <div style="text-align: center; margin-bottom: 20px;">
+                         <img alt="{ticker} Sentiment Chart" src="data:image/png;base64,{chart_base64}"
+                              style="max-width:850px; width:100%; display: block; margin:auto;">
+                     </div>"""
+            else:
+                ticker_html += f"<p>No plottable sentiment data available for {ticker}.</p>\n"
+
+            # Recent News Headlines (Details)
+            ticker_html += "<h5>News Headlines</h5>\n"
+            if ticker_news:
+                sorted_dates = sorted(ticker_news.keys(), reverse=True)
+                news_list_html = ""
+                for date_str in sorted_dates:
+                    news_items = ticker_news[date_str]
+                    if news_items:
+                        items_to_show = news_items[:self.configuration.news_items_per_day_limit]
+                        if items_to_show:
+                            news_list_html += f"{date_str}\n<ul class='list-unstyled'>\n"
+                            for item in items_to_show:
+                                safe_title = item.get('title', 'No Title').replace('<', '&lt;').replace('>', '&gt;')
+                                url = item.get('url', '#')
+                                news_list_html += (
+                                    f"  <li><a href='{url}' target='_blank' rel='noopener noreferrer'>"
+                                    f"{safe_title}</a></li>\n"
+                                )
+                            news_list_html += "</ul>\n"
+                ticker_html += news_list_html if news_list_html else "<p>No recent news headlines found based on limits.</p>\n"
+            else:
+                ticker_html += "<p>No news headlines found for this period.</p>\n"
+
+            ticker_html += '<hr style="margin: 30px 0;">\n'
+            ticker_sections_html += ticker_html
+        return ticker_sections_html
+
+    def run(self) -> str:
+        """
+        Orchestrates the report generation process:
+          1. Fetch data,
+          2. Create plots,
+          3. Attempt to retrieve article text (first 100 words) for all articles,
+          4. Generate a single combined summary from those snippets,
+          5. Render HTML,
+          6. Upload artifact.
+        """
+        logger.info(f"Running Sentiment Report with configuration: {self.configuration.model_dump()}")
+
+        # Step 1: Fetch sentiment and news data
+        all_sentiment_data, all_news_data = self._fetch_data()
+
+        # Step 2: Create a combined (all tickers) sentiment chart
+        valid_dfs = [df for df in all_sentiment_data.values() if not df.empty]
+        combined_chart_base64 = None
+        if valid_dfs:
+            combined_df = pd.concat(valid_dfs).groupby(level=0).sum()
+            combined_chart_base64 = self._generate_plot(combined_df, "All Tickers (Combined)")
+
+        if combined_chart_base64:
+            combined_chart_html = f"""
+                <h2>Combined Sentiment Across All Tickers</h2>
+                <p style="text-align:center;">
+                    <img alt="All Tickers Combined Sentiment Chart"
+                         src="data:image/png;base64,{combined_chart_base64}"
+                         style="max-width:850px; width:100%; display: block; margin:auto;">
+                </p><hr style="margin: 30px 0;">"""
+        else:
+            combined_chart_html = "<h2>Combined Sentiment</h2><p>No combined sentiment data available.</p><hr style='margin: 30px 0;'>"
+
+        # Step 3: Attempt to retrieve the first 100 words from each article and accumulate
+        article_snippets = self._download_article_previews(all_news_data=all_news_data)
+
+        # Step 4: Generate one single combined summary from all article snippets
+        combined_article_snippets_summary_html = ""
+        if article_snippets:
+            # Combine all snippets into one string
+            combined_text = "\n".join(article_snippets)
+            summary_prompt = (
+                f"Please summarize the following text in about 150 words, focus on the assets {self.tickers}:\n\n"
+                f"{combined_text}"
+            )
+            logger.info("\nGenerating combined summary of article snippets...")
+            try:
+                combined_summary_text = self.tdag_agent.query_agent(summary_prompt)
+                combined_article_snippets_summary_html = f"""
+                    <h3>Summary (AI-Generated)</h3>
+                    <p>{combined_summary_text}</p>
+                    <hr style="margin: 30px 0;">"""
+            except Exception as e:
+                logger.info(f"    Error generating combined summary: {e}")
+                combined_article_snippets_summary_html = (
+                    "<h3>Summary (AI-Generated)</h3>"
+                    f"<p>Error generating summary: {e}</p><hr>"
+                )
+        else:
+            combined_article_snippets_summary_html = (
+                "<h3>Summary (AI-Generated)</h3>"
+                "<p>No article snippets found to summarize.</p>"
+                "<hr>"
+            )
+
+        # Step 5: Build up the per-ticker sections
+        ticker_sections_html = self._format_ticker_sections(all_sentiment_data, all_news_data)
+
+        # Construct the overall report HTML
+        report_content_html = f"""
+            <h2>Overview</h2>
+            <p>This report summarizes daily sentiment counts (positive/negative/neutral)
+            derived from Polygon.io news article insights for each requested ticker,
+            within the date range {self.start_date} to {self.end_date}.</p>
+
+            {combined_chart_html}
+            {combined_article_snippets_summary_html}
+
+            {ticker_sections_html}
+        """
+
+        template_context = {
+            "report_title": self.configuration.report_title,
+            "report_id": self.configuration.report_id,
+            "current_date": datetime.now().strftime('%Y-%m-%d'),
+            "authors": self.configuration.authors,
+            "sector": self.configuration.sector,
+            "region": self.configuration.region,
+            "topics": ["Sentiment Analysis", "News Aggregation", "Market Data", "Equities"],
+            "current_year": datetime.now().year,
+            "summary": (
+                f"Daily sentiment analysis, plus combined and per-ticker summaries, "
+                f"for the {self.category_name} category from {self.start_date} to {self.end_date}."
+            ),
+            "report_content": report_content_html,
+            "logo_location": "https://main-sequence.app/static/media/logos/MS_logo_long_white.png",
+        }
+
+        template = self.jinja_env.get_template("report.html")
+        rendered_html = template.render(template_context)
+
+        output_html_path = os.path.join(os.path.dirname(__file__), "multi_ticker_sentiment_report.html")
+        try:
+            with open(output_html_path, "w", encoding="utf-8") as f:
+                f.write(rendered_html)
+            logger.info(f"\nHTML report generated successfully: {output_html_path}")
+            logger.info(f"View the report at: file://{os.path.abspath(output_html_path)}")
+        except Exception as e:
+            logger.info(f"\nError writing HTML report to file: {e}")
+
+        html_artifact = None
+        try:
+            html_artifact = Artifact.upload_file(
+                filepath=output_html_path,
+                name=self.configuration.report_id + f"_{self.category_name}.html",
+                created_by_resource_name=self.__class__.__name__,
+                bucket_name=self.configuration.bucket_name
+            )
+            logger.info(f"Artifact uploaded successfully: {html_artifact.id if html_artifact else 'Failed'}")
+        except Exception as e:
+            logger.info(f"Error uploading artifact: {e}")
+
+        self.add_output(html_artifact)
+        return html_artifact
+
+# --- Main Execution Guard ---
+if __name__ == "__main__":
+    try:
+        import kaleido
+    except ImportError:
+        logger.info("Warning: 'kaleido' package not found. Plotly image export might fail.")
+        logger.info("Consider installing it: pip install kaleido")
+
+    # Example configuration
+    config = SentimentReportConfig(
+        asset_category_unique_identifier="magnificent_7",
+        report_days=7,
+        report_title="Magnificent 7 News Sentiment & Headlines Report (Last 7 Days)",
+        report_id="Mag7_SentimentReport_7d"
+    )
+
+    # Create the App instance with config
+    app = SentimentReport(config)
+    # Run the report
+    generated_artifact = app.run()
+    if generated_artifact:
+        logger.info(f"\nReport generation complete. Artifact ID: {generated_artifact.id}")
+    else:
+        logger.info("\nReport generation completed, but artifact upload failed or was skipped.")

mainsequence/virtualfundbuilder/contrib/apps/portfolio_report_app.py

@@ -0,0 +1,91 @@
+import datetime
+import os
+from enum import Enum
+from typing import List
+
+import numpy as np
+import pandas as pd
+from mainsequence.client import Portfolio
+from mainsequence.reportbuilder.model import StyleSettings, ThemeMode
+from mainsequence.reportbuilder.slide_templates import generic_plotly_line_chart
+from mainsequence.virtualfundbuilder.utils import get_vfb_logger
+from plotly.subplots import make_subplots
+
+from pydantic import BaseModel
+from mainsequence.virtualfundbuilder.resource_factory.app_factory import BaseApp, register_app, HtmlApp
+import plotly.graph_objects as go
+
+logger = get_vfb_logger()
+
+portfolio_ids = [portfolio.id for portfolio in Portfolio.filter(local_time_serie__isnull=False)]
+
+class PortfolioReportConfiguration(BaseModel):
+    report_title: str = "Portfolio Report"
+    portfolio_ids: List[int] = portfolio_ids
+    report_days: int = 365 * 5
+
+@register_app()
+class PortfolioReport(HtmlApp):
+    configuration_class = PortfolioReportConfiguration
+
+    def run(self) -> str:
+        styles = StyleSettings(mode=ThemeMode.light)
+        start_date = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=self.configuration.report_days)
+
+        series_data = []
+        all_dates = pd.Index([])
+
+        portfolio_data_map = {}
+        for portfolio_id in self.configuration.portfolio_ids:
+            try:
+                portfolio = Portfolio.get(id=portfolio_id)
+                data = portfolio.local_time_serie.get_data_between_dates_from_api()
+                data['time_index'] = pd.to_datetime(data['time_index'])
+                report_data = data[data['time_index'] >= start_date].copy().sort_values('time_index')
+
+                if not report_data.empty:
+                    portfolio_data_map[portfolio_id] = report_data
+                    all_dates = all_dates.union(report_data['time_index'])
+
+            except Exception as e:
+                logger.error(f"Could not process portfolio {portfolio_id}. Error: {e}")
+
+        # Second loop: process and normalize data
+        for portfolio_id in self.configuration.portfolio_ids:
+            if portfolio_id in portfolio_data_map:
+                report_data = portfolio_data_map[portfolio_id]
+                portfolio = Portfolio.get(id=portfolio_id)
+
+                # Reindex to common date range and forward-fill missing values
+                processed_data = report_data.set_index('time_index').reindex(all_dates).ffill().reset_index()
+
+                # Normalize to 100 at the start of the common date range
+                first_price = processed_data['close'].iloc[0]
+                normalized_close = (processed_data['close'] / first_price) * 100
+
+                series_data.append({
+                    "name": portfolio.portfolio_name,
+                    "y_values": normalized_close,
+                    "color": styles.chart_palette_categorical[len(series_data) % len(styles.chart_palette_categorical)]
+                })
+
+        # Final check if any data was processed
+        if not series_data:
+            return "<html><body><h1>No data available for the selected portfolios and date range.</h1></body></html>"
+
+        # Call the generic function
+        html_chart = generic_plotly_line_chart(
+            x_values=list(all_dates),
+            series_data=series_data,
+            y_axis_title="Indexed Performance (Start = 100)",
+            theme_mode=styles.mode,
+            full_html=False,
+            include_plotlyjs = "cdn"
+        )
+        return html_chart
+
+if __name__ == "__main__":
+    configuration = PortfolioReportConfiguration(
+        portfolio_ids=portfolio_ids[:1]
+    )
+    PortfolioReport(configuration).run()

mainsequence/virtualfundbuilder/contrib/apps/portfolio_table.py

@@ -0,0 +1,95 @@
+import datetime
+from enum import Enum
+from typing import List, Union
+
+import numpy as np
+import pandas as pd
+from mainsequence.client import Portfolio
+from mainsequence.reportbuilder.model import StyleSettings, ThemeMode
+from mainsequence.reportbuilder.slide_templates import generic_plotly_table
+from mainsequence.virtualfundbuilder.utils import get_vfb_logger
+from pydantic import BaseModel
+from mainsequence.virtualfundbuilder.resource_factory.app_factory import (
+    HtmlApp,
+    register_app,
+)
+
+logger = get_vfb_logger()
+
+portfolio_ids = [portfolio.id for portfolio in Portfolio.filter(local_time_serie__isnull=False)]
+
+class ReportType(Enum):
+    FIXED_INCOME = "fixed_income"
+    LIQUIDITY = "liquidity"
+
+class PortfolioTableConfiguration(BaseModel):
+    report_title: str = "Portfolio Table"
+    report_type: ReportType = ReportType.FIXED_INCOME
+    portfolio_ids: List[int] = portfolio_ids
+    report_days: int = 365 * 5
+
+@register_app()
+class PortfolioTable(HtmlApp):
+    configuration_class = PortfolioTableConfiguration
+
+    def run(self) -> str:
+        style = StyleSettings(mode=ThemeMode.light)
+        shared_column_widths = [1.8, 1, 1, 1.5, 0.7, 0.8, 0.8, 0.7]
+        shared_cell_align: Union[str, List[str]] = ['left', 'right', 'right', 'right', 'right', 'right', 'right', 'right']
+        table_figure_width = 900
+
+        # Use paragraph font family for charts from the theme
+        chart_font_family = style.font_family_paragraphs
+        chart_label_font_size = style.chart_label_font_size
+
+        if self.configuration.report_type == ReportType.FIXED_INCOME:
+            fixed_income_local_headers = ["INSTRUMENT", "UNITS", "PRICE", "AMOUNT", "% TOTAL", "DURATION", "YIELD", "DxV"]
+            fixed_income_local_rows = [
+                ["Alpha Bond 2025", "350,000", "$99.50", "$34,825,000.00", "7.50%", "0.25", "9.05%", "90"],
+                ["Beta Note 2026", "160,000", "$99.80", "$15,968,000.00", "3.60%", "1.30", "9.15%", "530"],
+                ["Gamma Security 2026", "250,000", "$99.90", "$24,975,000.00", "5.60%", "1.50", "9.20%", "600"],
+                ["Delta Issue 2027", "245,000", "$100.10", "$24,524,500.00", "5.40%", "1.60", "9.25%", "630"],
+                ["Epsilon Paper 2026", "200,000", "$98.50", "$19,700,000.00", "4.40%", "0.80", "8.30%", "300"],
+                ["Zeta Bond 2029", "170,000", "$102.50", "$17,425,000.00", "3.90%", "3.30", "8.60%", "1,500"],
+                ["Eta Security 2030", "180,000", "$100.00", "$18,000,000.00", "4.00%", "3.80", "8.80%", "1,700"],
+                ["Theta Note 2034", "110,000", "$93.00", "$10,230,000.00", "2.30%", "6.30", "9.30%", "3,500"],
+                ["Iota UDI 2028", "40,000", "$98.00", "$33,600,000.00", "7.90%", "3.20", "4.90%", "1,300"],
+                ["Kappa C-Bill 2026A", "2,500,000", "$9.20", "$23,000,000.00", "5.10%", "0.85", "8.40%", "340"],
+                ["Lambda C-Bill 2026B", "3,300,000", "$8.80", "$29,040,000.00", "6.70%", "1.25", "8.50%", "520"],
+                ["TOTAL", "", "", "$251,287,500.00", "56.70%", "1.60", "8.55%", "480"]
+            ]
+
+
+
+            html_table = generic_plotly_table(
+                headers=fixed_income_local_headers, rows=fixed_income_local_rows,
+                column_widths=shared_column_widths, cell_align=shared_cell_align, fig_width=table_figure_width,
+                header_font_dict=dict(color=style.background_color, size=10, family=chart_font_family),
+                cell_font_dict=dict(size=chart_label_font_size, family=chart_font_family, color=style.paragraph_color),
+                theme_mode=style.mode, full_html=False, include_plotlyjs="cdn"
+            )
+        else:
+            liquidity_headers = ["INSTRUMENT", "UNITS", "PRICE", "AMOUNT", "% TOTAL", "DURATION", "YIELD", "DxV"]
+            liquidity_rows = [
+                ["Repo Agreement", "", "", "$55,000,000.00", "12.50%", "0.01", "9.50%", "5"],
+                ["Cash Equiv. (Local)", "", "", "$150.00", "0.00%", "", "", ""],
+                # ["Cash Equiv. (USD)", "50,000", "", "$1,000,000.00", "0.20%", "", "", ""],
+                # ["TOTAL", "", "", "$56,000,150.00", "12.70%", "", "", ""]
+            ]
+
+            html_table = generic_plotly_table(
+                headers=liquidity_headers, rows=liquidity_rows,
+                column_widths=shared_column_widths, cell_align=shared_cell_align, fig_width=table_figure_width,
+                header_font_dict=dict(color=style.background_color, size=10, family=chart_font_family),
+                cell_font_dict=dict(size=chart_label_font_size, family=chart_font_family, color=style.paragraph_color),
+                theme_mode=style.mode, full_html=False, include_plotlyjs="cdn"
+            )
+        return html_table
+
+
+if __name__ == "__main__":
+    cfg = PortfolioTableConfiguration(
+        report_type=ReportType.LIQUIDITY,
+        portfolio_ids=portfolio_ids[:1]
+    )
+    PortfolioTable(cfg).run()

mainsequence/virtualfundbuilder/contrib/apps/run_named_portfolio.py

@@ -0,0 +1,45 @@
+from enum import Enum
+
+from mainsequence.virtualfundbuilder.models import PortfolioConfiguration
+from mainsequence.virtualfundbuilder.portfolio_interface import PortfolioInterface
+from mainsequence.virtualfundbuilder.utils import get_vfb_logger
+
+from pydantic import BaseModel
+from mainsequence.client.models_tdag import Artifact
+from mainsequence.virtualfundbuilder.resource_factory.app_factory import BaseApp, register_app
+
+logger = get_vfb_logger()
+
+class PortfolioRunParameters(BaseModel):
+    add_portfolio_to_markets_backend: bool = True
+    update_tree: bool = True
+
+PortfolioNameEnum = Enum(
+    "PortfolioNameEnum",
+    {name: name for name in PortfolioInterface.list_configurations()},
+    type=str,          # make each member a `str`, so validation works as before
+)
+class NamedPortfolioConfiguration(BaseModel):
+    portfolio_name: PortfolioNameEnum
+    portfolio_run_parameters: PortfolioRunParameters
+
+@register_app()
+class RunNamedPortfolio(BaseApp):
+    configuration_class = NamedPortfolioConfiguration
+
+    def __init__(self, configuration: NamedPortfolioConfiguration):
+        logger.info(f"Run Named Timeseries Configuration {configuration}")
+        self.configuration = configuration
+
+    def run(self) -> None:
+        from mainsequence.virtualfundbuilder.portfolio_interface import PortfolioInterface
+        portfolio = PortfolioInterface.load_from_configuration(self.configuration.portfolio_name)
+        res = portfolio.run(**self.configuration.portfolio_run_parameters.model_dump())
+        logger.info(f"Portfolio Run successful with results {res.head()}")
+
+if __name__ == "__main__":
+    configuration = NamedPortfolioConfiguration(
+        portfolio_run_parameters=PortfolioRunParameters(),
+        portfolio_name="market_cap"
+    )
+    RunNamedPortfolio(configuration).run()