Overall Statistics
Total Orders
0
Average Win
0%
Average Loss
0%
Compounding Annual Return
0%
Drawdown
0%
Expectancy
0
Start Equity
100000
End Equity
100000
Net Profit
0%
Sharpe Ratio
0
Sortino Ratio
0
Probabilistic Sharpe Ratio
0%
Loss Rate
0%
Win Rate
0%
Profit-Loss Ratio
0
Alpha
0
Beta
0
Annual Standard Deviation
0
Annual Variance
0
Information Ratio
9.739
Tracking Error
0.064
Treynor Ratio
0
Total Fees
$0.00
Estimated Strategy Capacity
$0
Lowest Capacity Asset
Portfolio Turnover
0%
 
# region imports
from AlgorithmImports import *
from datetime import timedelta
# endregion

class IVTSAlpha(AlphaModel):
    
    securities = []


    def update(self, algorithm: QCAlgorithm, data: Slice) -> List[Insight]:
        insights = []

        for security in self.securities:
            
            insight = Insight(security.symbol, timedelta(minutes=60), InsightType.PRICE, InsightDirection.UP)
            insights.append(insight)
            return Insight.group(insights)


    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            self.securities.append(security)

        for security in changes.removed_securities:
            if security in self.securities:
                self.securities.remove(security)

#region imports
from AlgorithmImports import *
from universe import *
from alpha import *
from portfolio import *
#endregion

class ConservativeApgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2024, 1, 1)
        self.set_end_date(2024, 1, 7)
        self.set_cash(100_000)            
        self.set_brokerage_model(BrokerageName.INTERACTIVE_BROKERS_BROKERAGE, AccountType.MARGIN)

        # SPY 500 companies
        spy = self.add_equity("SPY",
            resolution = Resolution.MINUTE,
            data_normalization_mode = DataNormalizationMode.RAW).symbol
        self.set_benchmark(spy)
        
        self.set_universe_selection(etf_constituents_universe(spy, self.universe_settings))
        self.set_alpha(IVTSAlpha())
        self.Settings.RebalancePortfolioOnInsightChanges = False
        self.Settings.RebalancePortfolioOnSecurityChanges = False
        self.set_portfolio_construction(StraddlePortfolio())
        self.set_risk_management(NullRiskManagementModel())
        self.set_execution(NullExecutionModel())


# region imports
from AlgorithmImports import *
# endregion

# Portfolio construction scaffolding class; basic method args.
class StraddlePortfolio(PortfolioConstructionModel):
    # Create list of PortfolioTarget objects from Insights
    def create_targets(self, algorithm: QCAlgorithm, insights: List[Insight]) -> List[PortfolioTarget]:
        return super().create_targets(algorithm, insights)
    
    # Determines the target percent for each insight
    def determine_target_percent(self, insights: List[Insight]) -> Dict[Insight, float]:
        
        targets = {}

        for insight in insights:
            # For simplicity, let's just evenly divide the portfolio among all insights
            targets[insight] = 1.0 / len(insights)

        return targets
# region imports
from AlgorithmImports import *
# endregion

class etf_constituents_universe(ETFConstituentsUniverseSelectionModel):
    def __init__(self, benchmark, universe_settings: UniverseSettings = None) -> None:
        super().__init__(benchmark, universe_settings, self.etf_constituents_filter)

    def etf_constituents_filter(self, constituents):
        return [c.symbol for c in constituents]