Nasdaq

from AlgorithmImports import *


class NasdaqImporterAlgorithm(QCAlgorithm):

    def initialize(self):
        self.nasdaq_code = "QDL/BITFINEX"
        ## Optional argument - personal token necessary for restricted dataset
        # NasdaqDataLink.set_auth_code(self.get_parameter("nasdaq-data-link-api-key"))
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(25000)
        # Request nasdaq data link data to trade
        self.add_data(NasdaqCustomColumns, self.nasdaq_code, Resolution.DAILY, TimeZones.NEW_YORK)
        # Create SMA indicator that feed with nasdaq data link data, which can be used to determine trend for trend following trade
        self.sma = self.SMA(self.nasdaq_code, 14)

    def on_data(self, data):
        if not self.portfolio.hold_stock:
            self.set_holdings(self.nasdaq_code, 1)
            self.debug("Purchased {0} >> {1}".format(self.nasdaq_code, self.time))

        self.plot(self.nasdaq_code, "PriceSMA", self.sma.current.value)

# NasdaqDataLink often doesn't use close columns so need to tell LEAN which is the "value" column.
class NasdaqCustomColumns(NasdaqDataLink):
    def __init__(self):
        # Define ValueColumnName: cannot be None, Empty or non-existant column name
        super().__init__("mid")
        self.value_column_name = "mid"

public class NasdaqImporterAlgorithm : QCAlgorithm
{
    private string nasdaqCode = "QDL/BITFINEX";
    private SimpleMovingAverage sma;

    public override void Initialize()
    {
        // Optional argument - personal token necessary for restricted dataset
        // NasdaqDataLink.SetAuthCode(this.GetParameter("nasdaq-data-link-api-key"));
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(25000); 
        // Request nasdaq data link data to trade
        AddData<NasdaqCustomColumns>(nasdaqCode, Resolution.Daily, TimeZones.NewYork);
        // Create SMA indicator that feed with nasdaq data link data, which can be used to determine trend for trend following trade
        sma = SMA(nasdaqCode, 14);
    }

    public override void OnData(Slice data)
    {
        // OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
        if (!Portfolio.HoldStock)
        {
            SetHoldings(nasdaqCode, 1);
            Debug("Purchased " + nasdaqCode + " >> " + Time);
        }

        Plot(nasdaqCode, "PriceSMA", sma.Current.Value);
    }
}

// NasdaqDataLink often doesn't use close columns so need to tell LEAN which is the "value" column.
public class NasdaqCustomColumns : NasdaqDataLink
{
    // Custom nasdaq data type for setting customized value column name.
    // Value column is used for the primary trading calculations and charting.
    public NasdaqCustomColumns() : base("mid")
    {
        ValueColumnName = "mid";
    }
}

from AlgorithmImports import *


class NasdaqDataLinkFrameworkAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(1000000)

        ### Requesting Data
        # For premium datasets, provide your API Key
        # NasdaqDataLink.set_auth_code(self.get_parameter("nasdaq-data-link-api-key"))

        # Add nasdaq data link data as trading vehicle
        bitfinex_exchange_rate_symbol = self.add_data(NasdaqDataLink, 'QDL/BCHAIN', Resolution.DAILY).symbol

        ### Historical Data
        history = self.history(bitfinex_exchange_rate_symbol, 1000, Resolution.DAILY)
        self.debug(f"We got {len(history)} items from our history request for {bitfinex_exchange_rate_symbol} Nasdaq Data Link")

        # Custom alpha model that emit insights based on updated nasdaq data link data
        self.add_alpha(NasdaqDataLinkAlphaModel(self))

        # Invest equally to evenly dissipate the capital concentration risk
        self.set_portfolio_construction(EqualWeightingPortfolioConstructionModel(lambda time: None))
        
        
class NasdaqDataLinkAlphaModel(AlphaModel):
    def __init__(self, algorithm: QCAlgorithm) -> None:        
        ### Requesting NASDAQ data link custom data   
        self.bitfinex_exchange_rate_symbol = algorithm.add_data(NasdaqCustomColumns, "QDL/BITFINEX", Resolution.DAILY).symbol
        # This dataset has multiple data columns, so create a custom class to set the value column name

        ### Historical Data
        history = algorithm.history(self.bitfinex_exchange_rate_symbol, 100, Resolution.DAILY)
        algorithm.debug(f"We got {len(history)} items from our history request for {self.bitfinex_exchange_rate_symbol} Nasdaq Data Link")

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

        # Trade only based on updated NASDAQ data link data
        for dataset_symbol, data_point in slice.Get(NasdaqCustomColumns).items():
            if dataset_symbol != self.bitfinex_exchange_rate_symbol or algorithm.portfolio[dataset_symbol].invested:
                continue
            insights.append(Insight.price(dataset_symbol, timedelta(days=6*22), InsightDirection.UP))
            
        return insights

# NasdaqDataLink often doesn't use close columns so need to tell LEAN which is the "value" column.
class NasdaqCustomColumns(NasdaqDataLink):
    def __init__(self) -> None:
        # Select the column "mid".
        self.value_column_name = "mid" 

public class NasdaqDataLinkFrameworkAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);
        
        /// Requesting Data
        // For premium datasets, provide your API Key
        // NasdaqDataLink.SetAuthCode(GetParameter("nasdaq-data-link-api-key"));

        // Add nasdaq data link data as trading vehicle
        var bitcoinChainSymbol = AddData<NasdaqDataLink>("QDL/BCHAIN", Resolution.Daily).Symbol;

        /// Historical Data
        var history = History<NasdaqDataLink>(bitcoinChainSymbol, 1000, Resolution.Daily);
        Debug($"We got {history.Count()} items from our history request for {bitcoinChainSymbol} Nasdaq Data Link");

        // Custom alpha model that emit insights based on updated nasdaq data link data
        AddAlpha(new NasdaqDataLinkAlphaModel(this));

        // Invest equally to evenly dissipate the capital concentration risk
        SetPortfolioConstruction(new EqualWeightingPortfolioConstructionModel(time => null));
    }
}

public class NasdaqDataLinkAlphaModel : AlphaModel
{
    private Symbol _bitfinexExchangeRateSymbol;

    public NasdaqDataLinkAlphaModel(QCAlgorithm algorithm)
    {
        /// Requesting NASDAQ data link custom data   
        _bitfinexExchangeRateSymbol = algorithm.AddData<NasdaqCustomColumns>("QDL/BITFINEX", Resolution.Daily).Symbol;
        // This dataset has multiple data columns, so create a custom class to set the value column name

        /// Historical Data
        var history = algorithm.History<NasdaqCustomColumns>(_bitfinexExchangeRateSymbol, 100, Resolution.Daily);
        algorithm.Debug($"We got {history.Count()} items from our history request for {_bitfinexExchangeRateSymbol} Nasdaq Data Link");
    }

    public override List<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        List<Insight> insights = new List<Insight>();
        
        /// Trade only based on updated NASDAQ data link data
        foreach (var kvp in slice.Get<NasdaqCustomColumns>())
        {
            var datasetSymbol = kvp.Key;
            if (datasetSymbol != _bitfinexExchangeRateSymbol || algorithm.Portfolio[datasetSymbol].Invested)
            {
                continue;
            }
            insights.Add(Insight.Price(datasetSymbol, TimeSpan.FromDays(6*22), InsightDirection.Up));
        }

        return insights;
    }
}

public class NasdaqCustomColumns : NasdaqDataLink
{
    // Select the column "mid".
    public NasdaqCustomColumns() : base(valueColumnName: "mid") { }
}