United States Patent and Trademark Office

from AlgorithmImports import *
from QuantConnect.DataSource import *

class USPTOAlgorithm(QCAlgorithm):
    '''Example algorithm that trades IBM on its patent maintenance activity.'''

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        self.set_cash(100000)

        self._ibm = self.add_equity("IBM", Resolution.DAILY).symbol

        # Add the USPTO patent maintenance data for IBM.
        self._patents = self.add_data(USPTOPatentMaintenance, self._ibm).symbol

        # Track the last 13 weekly net maintenance changes.
        self._net = RollingWindow(13)

    def on_data(self, slice: Slice) -> None:
        points = slice.get(USPTOPatentMaintenance)
        if self._patents not in points:
            return

        point = points[self._patents]
        self.debug(f"{self.time:%Y-%m-%d} expired: {point.patents_expired}, "
                   f"renewed 12yr: {point.maintenance_paid_twelfth_year}")

        if point.net_maintenance_change is None:
            return

        if self._net.is_ready:
            # Buy above the trailing average and liquidate below it.
            average = sum(self._net) / self._net.count
            if point.net_maintenance_change > average and not self.portfolio[self._ibm].invested:
                self.set_holdings(self._ibm, 1)
            elif point.net_maintenance_change < average and self.portfolio[self._ibm].invested:
                self.liquidate(self._ibm)

        self._net.add(point.net_maintenance_change)

    def on_order_event(self, order_event: OrderEvent) -> None:
        if order_event.status == OrderStatus.FILLED:
            self.debug(f"{self.time} - Filled: {order_event.symbol} {order_event.fill_quantity}")

using QuantConnect.Data;
using QuantConnect.Orders;
using QuantConnect.Algorithm;
using QuantConnect.DataSource;
using QuantConnect.Indicators;

/// <summary>
/// Example algorithm that trades IBM on its patent maintenance activity.
/// </summary>
public class USPTOAlgorithm : QCAlgorithm
{
    private Symbol _ibm;
    private Symbol _patents;
    private RollingWindow<decimal> _net;

    /// <summary>
    /// Initialise the data and resolution required, as well as the cash and start-end dates.
    /// </summary>
    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetEndDate(2021, 1, 1);
        SetCash(100000);

        _ibm = AddEquity("IBM", Resolution.Daily).Symbol;

        // Add the USPTO patent maintenance data for IBM.
        _patents = AddData<USPTOPatentMaintenance>(_ibm).Symbol;

        // Track the last 13 weekly net maintenance changes.
        _net = new RollingWindow<decimal>(13);
    }

    /// <summary>
    /// Trade IBM on each new patent maintenance data point.
    /// </summary>
    /// <param name="slice">Slice object keyed by symbol containing the data</param>
    public override void OnData(Slice slice)
    {
        var points = slice.Get<USPTOPatentMaintenance>();
        if (!points.ContainsKey(_patents))
        {
            return;
        }

        var point = points[_patents];
        Debug($"{Time:yyyy-MM-dd} expired: {point.PatentsExpired}, renewed 12yr: {point.MaintenancePaidTwelfthYear}");

        if (!point.NetMaintenanceChange.HasValue)
        {
            return;
        }

        if (_net.IsReady)
        {
            // Buy above the trailing average and liquidate below it.
            var total = 0m;
            foreach (var value in _net)
            {
                total += value;
            }

            var average = total / _net.Count;
            if (point.NetMaintenanceChange.Value > average && !Portfolio[_ibm].Invested)
            {
                SetHoldings(_ibm, 1);
            }
            else if (point.NetMaintenanceChange.Value < average && Portfolio[_ibm].Invested)
            {
                Liquidate(_ibm);
            }
        }

        _net.Add(point.NetMaintenanceChange.Value);
    }

    /// <summary>
    /// Log each order fill.
    /// </summary>
    /// <param name="orderEvent">Order event details</param>
    public override void OnOrderEvent(OrderEvent orderEvent)
    {
        if (orderEvent.Status.IsFill())
        {
            Debug($"{Time} - Filled: {orderEvent.Symbol} {orderEvent.FillQuantity}");
        }
    }
}