from AlgorithmImports import *

class USEnergyDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        
        # Requesting data
        self.axas = self.add_equity("AXAS", Resolution.DAILY).symbol
        us_energy_symbol = self.add_data(USEnergy, USEnergy.Petroleum.UnitedStates.WEEKLY_NET_IMPORTS_OF_TOTAL_PETROLEUM_PRODUCTS).symbol

        # Historical data
        history = self.history(USEnergy, us_energy_symbol, 60, Resolution.DAILY)
        self.log(f"We got {len(history)} items from our history request")

        # Get latest value for net imports of petroleum products
        self.previous_value = history.loc[us_energy_symbol].values[-1, -1]
        
    def on_data(self, slice: Slice) -> None:
        # Gather the current net imports of petroleum products
        points = slice.get(USEnergy).values()
        if not points:
            return
        current_value = points[-1].value
        
        # Buy when net imports of petroleum products are increasing
        if current_value > self.previous_value:
            self.set_holdings(self.axas, 1)
        
        # Short sell when net imports of petroleum products are decreasing
        elif current_value < self.previous_value:
            self.set_holdings(self.axas, -1)
        
        self.previous_value = current_value

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEnergyDataAlgorithm : QCAlgorithm
    {
        private decimal? previousValue;
        private Symbol tradableSymbol;
        
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            
            // Requesting data, we trade Abraxas Petroleum Corporation (AXAS) as the proxy of petroleum investment
            tradableSymbol = AddEquity("AXAS", Resolution.Daily).Symbol;
            // Request US weekly net import petroleum products data for trade signal generation
            var USEnergySymbol = AddData<USEnergy>(USEnergy.Petroleum.UnitedStates.WeeklyNetImportsOfTotalPetroleumProducts).Symbol;

            // Historical data            
            var history = History<USEnergy>(USEnergySymbol, 60, Resolution.Daily);
            Debug($"We got {history.Count()} items from our history request");
            
            // Get latest value for net imports of petroleum products for trade system readiness
            previousValue = history.Last().Value;
        }

        
        public override void OnData(Slice slice)
        {
            // Trade based on the current net imports of petroleum products
            var points = slice.Get<USEnergy>();
            decimal? currentValue = null;
            foreach (var point in points.Values)
            {
                currentValue = point.Value;
            }
            if (currentValue == null)
            {
                return;
            }
            
            // Buy when net imports of petroleum products are increasing, assuming the demand increases that bring up the petroleum price
            // Hence the inventory and revenue of the proxy increase, supporting the stock price goes up
            if (currentValue > previousValue)
            {
                SetHoldings(tradableSymbol, 1);
            }
            
            //  Short sell when net imports of petroleum products are decreasing, decreasing demand lowers the petroleum price and the proxy stock price
            if (currentValue < previousValue)
            {
                SetHoldings(tradableSymbol, -1);
            }
            
            previousValue = currentValue;
        }
    }
}

from AlgorithmImports import *

class USEnergyDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        
        self.universe_settings.resolution = Resolution.DAILY
        # We only trade Abraxas Petroleum Corporation (AXAS) as the proxy of petroleum investment
        symbols = [Symbol.create("AXAS", SecurityType.EQUITY, Market.USA)]
        self.add_universe_selection(ManualUniverseSelectionModel(symbols))   
        # A custom alpha model that emit trade insights based on US Energy data
        self.add_alpha(USEnergyAlphaModel(self))
        # Equally invest to dissipate non-systematic capital concentration risk on individual stock
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel())

class USEnergyAlphaModel(AlphaModel):
    
    tradable_symbols = []
    
    def __init__(self, algorithm: QCAlgorithm) -> None:
        # Request US weekly net import petroleum products data for trade signal generation
        self.us_energy_symbol = algorithm.add_data(USEnergy, USEnergy.Petroleum.UnitedStates.WEEKLY_NET_IMPORTS_OF_TOTAL_PETROLEUM_PRODUCTS).symbol
        
        # Historical data
        history = algorithm.history(USEnergy, self.us_energy_symbol, 60, Resolution.DAILY)
        algorithm.log(f"We got {len(history)} items from our history request")
        # Get latest value for net imports of petroleum products for trade system readiness
        self.previous_value = history.loc[self.us_energy_symbol].values[-1, -1]
    
    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        # Trade based on the current net imports of petroleum products
        points = slice.get(USEnergy).values()
        if not points:
            return []
        current_value = points[-1].value

        insights = []
        
        for symbol in self.tradable_symbols:
            # Buy when net imports of petroleum products are increasing, assuming the demand increases that bring up the petroleum price
            # Hence the inventory and revenue of the proxy increase, supporting the stock price goes up
            if current_value > self.previous_value:
                insights += [Insight.price(symbol, timedelta(days=7), InsightDirection.UP)]
            
            # Short sell when net imports of petroleum products are decreasing, decreasing demand lowers the petroleum price and the proxy stock price
            elif current_value < self.previous_value:
                insights += [Insight.price(symbol, timedelta(days=7), InsightDirection.DOWN)]
        
        self.previous_value = current_value
        return insights
        
    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            self.tradable_symbols.append(security.symbol)

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEnergyDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            
            UniverseSettings.Resolution = Resolution.Daily;
            // We only trade Abraxas Petroleum Corporation (AXAS) as the proxy of petroleum investment
            var symbols = new[] {QuantConnect.Symbol.Create("AXAS", SecurityType.Equity, Market.USA)};
            AddUniverseSelection(new ManualUniverseSelectionModel(symbols));
            // A custom alpha model that emit trade insights based on US Energy data
            AddAlpha(new USEnergyAlphaModel(this));
            // Equally invest to dissipate non-systematic capital concentration risk on individual stock
            SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel());
        }
    }


    public class USEnergyAlphaModel : AlphaModel
    {
        private Symbol USEnergySymbol;
        private List<Symbol> tradableSymbols = new List<Symbol>();
        private decimal? previousValue;
        
        public USEnergyAlphaModel(QCAlgorithm algorithm)
        {
            // Request US weekly net import petroleum products data for trade signal generation
            USEnergySymbol = algorithm.AddData<USEnergy>(USEnergy.Petroleum.UnitedStates.WeeklyNetImportsOfTotalPetroleumProducts).Symbol;
            
            // Historical data
            var history = algorithm.History<USEnergy>(USEnergySymbol, 60, Resolution.Daily);
            algorithm.Debug($"We got {history.Count()} items from our history request");
            // Get latest value for net imports of petroleum products for trade system readiness
            previousValue = history.Last().Value;
        }

        public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
        {
            var insights = new List<Insight>();
            
            // Trade based on the current net imports of petroleum products
            var points = slice.Get<USEnergy>();
            decimal? currentValue = null;
            foreach (var point in points.Values)
            {
                currentValue = point.Value;
            }
            if (currentValue == null)
            {
                return insights;
            }
            
            foreach (var symbol in tradableSymbols)
            {
                // Buy when net imports of petroleum products are increasing, assuming the demand increases that bring up the petroleum price
                // Hence the inventory and revenue of the proxy increase, supporting the stock price goes up
                if (currentValue > previousValue)
                {
                    insights.Add(Insight.Price(symbol, TimeSpan.FromDays(7),  InsightDirection.Up));
                }
                
                //  Short sell when net imports of petroleum products are decreasing, decreasing demand lowers the petroleum price and the proxy stock price
                if (currentValue < previousValue)
                {
                    insights.Add(Insight.Price(symbol, TimeSpan.FromDays(7),  InsightDirection.Down));
                }    
            }
            
            previousValue = currentValue;
            return insights;
        }

        public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
        {
            foreach (var security in changes.AddedSecurities)
            {
                tradableSymbols.Add(security.Symbol);
            }
        }
    }
}