Need To Hire For My Project

from AlgorithmImports import *

class HollyPaperAlgorithm(QCAlgorithm):
    """Production-ready skeleton that integrates mocked Holly/Azure signals,
    intraday trading gates, multi-layer risk controls, smart rotation, 
    EOD flattening, concise logging, and a self-learning stub. 
    All orders are MARKET and PAPER-only.
    """

    def initialize(self) -> None:
        # ---------------------------------------------------------------
        # 1. CONFIGURATION PARAMETERS  (tunable by self-learning stub)
        # ---------------------------------------------------------------
        self._config: dict = {
            "max_positions": 3,                  # simultaneous holdings
            "dollar_per_trade": 10_000,          # fixed notional sizing
            "trailing_stop_percent": 0.03,       # 3 % trailing stop
            "max_hold_minutes": 240,             # time stop (4 h)
            "daily_profit_target": 400,          # daily guard rails
            "daily_loss_limit":  -200,
            "price_threshold": 5,                # Holly filter
            "rvol_threshold": 2,
        }

        # ---------------------------------------------------------------
        # 2. STANDARD QC SETUP
        # ---------------------------------------------------------------
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # reference symbol for scheduling
        self._spy = self.add_equity("SPY", Resolution.MINUTE,
                                   data_normalization_mode=DataNormalizationMode.RAW).symbol

        # ---------------------------------------------------------------
        # 3. RUNTIME STATE CONTAINERS
        # ---------------------------------------------------------------
        self._signals, self._candidates = [], []
        self._added_symbols: set[Symbol] = {self._spy}

        self._stop_order_ids, self._high_since_entry = {}, {}
        self._entry_time, self._position_scores = {}, {}

        self._prev_total_profit: float = 0.0
        self._trading_disabled_today: bool = False

        # ---------------------------------------------------------------
        # 4. SCHEDULED TASKS
        # ---------------------------------------------------------------
        self.schedule.on(self.date_rules.every_day(), self.time_rules.at(9, 0),
                         self._pre_market_analysis)
        self.schedule.on(self.date_rules.every_day(), self.time_rules.at(9, 33),
                         self._trade_candidates)
        self.schedule.on(self.date_rules.every_day(), self.time_rules.at(15, 55),
                         self._eod_flatten)
        self.schedule.on(self.date_rules.every_day(), self.time_rules.at(16, 10),
                         self._daily_reset)

    # ------------------------------------------------------------------
    # 5. PRE-MARKET PREPARATION
    # ------------------------------------------------------------------
    def _pre_market_analysis(self) -> None:
        if self._trading_disabled_today:
            return

        self._signals = self._get_mock_holly_signals()
        price_thr, rvol_thr = self._config["price_threshold"], self._config["rvol_threshold"]

        filtered = [s for s in self._signals if s["price"] > price_thr and s["rvol"] > rvol_thr]
        filtered.sort(key=lambda s: s["score"], reverse=True)
        self._candidates = filtered[: self._config["max_positions"]]

        for pick in self._candidates:
            pick["symbol"] = self._ensure_security(pick["ticker"])

        self.log(f"[Pre-Market] Candidates: {[p['ticker'] for p in self._candidates]}")

    # ------------------------------------------------------------------
    # 6. OPENING-BELL EXECUTION (09:33 ET+)
    # ------------------------------------------------------------------
    def _trade_candidates(self) -> None:
        if self._trading_disabled_today:
            self.log("[Trade] Disabled by guard rails.")
            return

        open_positions = sum(1 for s in self.portfolio.values() if s.invested)

        for pick in self._candidates:
            symbol, score = pick["symbol"], pick["score"]
            if self.portfolio[symbol].invested:
                continue

            if open_positions < self._config["max_positions"]:
                qty = self._position_size(symbol)
                if qty > 0:
                    self.market_order(symbol, qty, tag=f"Entry|Score:{score}")
                    open_positions += 1
            else:
                worst_sym, worst_score = self._worst_profitable_position()
                if worst_sym and score > worst_score:
                    self.log(f"[Rotate] {worst_sym} (score {worst_score}) → {symbol} (score {score}).")
                    self.liquidate(worst_sym, tag="RotationOut")
                    qty = self._position_size(symbol)
                    if qty > 0:
                        self.market_order(symbol, qty, tag=f"Entry|Score:{score}")

    # ------------------------------------------------------------------
    # 7. REAL-TIME RISK MANAGEMENT
    # ------------------------------------------------------------------
    def on_data(self, slice: Slice) -> None:
        daily_pnl = self.portfolio.total_profit - self._prev_total_profit
        if (not self._trading_disabled_today and
           (daily_pnl >= self._config["daily_profit_target"] or
            daily_pnl <= self._config["daily_loss_limit"])):
            self.log(f"[GuardRails] P&L {daily_pnl:.2f} -> Flattening.")
            self.liquidate(tag="DailyPnLGuard")
            self._trading_disabled_today = True
            return

        # trailing & time-stop maintenance
        for symbol, entry_time in list(self._entry_time.items()):
            if not self.portfolio[symbol].invested:
                continue

            price = self.securities[symbol].price
            if price <= 0:
                continue

            self._high_since_entry[symbol] = max(price, self._high_since_entry[symbol])
            new_stop = self._high_since_entry[symbol] * (1 - self._config["trailing_stop_percent"])

            order_id = self._stop_order_ids.get(symbol)
            if order_id:
                order = self.transactions.get_order_by_id(order_id)
                if order and new_stop > order.stop_price:
                    ticket = self.transactions.get_order_ticket(order_id)
                    fields = UpdateOrderFields()
                    fields.stop_price = new_stop
                    fields.tag = f"Trail@{self.time:%H:%M}"
                    ticket.update(fields)

            if (self.time - entry_time).total_seconds() / 60 >= self._config["max_hold_minutes"]:
                self.log(f"[TimeStop] {symbol} – closing after time limit.")
                self.liquidate(symbol, tag="TimeStop")

    # ------------------------------------------------------------------
    # 8. ORDER-EVENT HANDLER
    # ------------------------------------------------------------------
    def on_order_event(self, evt: OrderEvent) -> None:
        if evt.status != OrderStatus.FILLED:
            return

        order = self.transactions.get_order_by_id(evt.order_id)
        tag, symbol = order.tag if order else "", evt.symbol

        if "Entry" in tag:   # new position
            entry_price = evt.fill_price
            self._high_since_entry[symbol] = entry_price
            self._entry_time[symbol] = self.time
            self._position_scores[symbol] = self._parse_score(tag)

            stop_price = entry_price * (1 - self._config["trailing_stop_percent"])
            qty = -self.portfolio[symbol].quantity
            if qty:
                ticket = self.stop_market_order(symbol, qty, stop_price, tag="TrailingStop")
                if ticket and ticket.status != OrderStatus.INVALID:
                    self._stop_order_ids[symbol] = ticket.order_id
        else:                # exit – clean up
            self._stop_order_ids.pop(symbol, None)
            self._high_since_entry.pop(symbol, None)
            self._entry_time.pop(symbol, None)
            self._position_scores.pop(symbol, None)

    # ------------------------------------------------------------------
    # 9. END-OF-DAY FLATTEN & DAILY RESET
    # ------------------------------------------------------------------
    def _eod_flatten(self) -> None:
        self.log("[EOD] Flattening at 15:55.")
        self.liquidate(tag="EODFlatten")
        for oid in list(self._stop_order_ids.values()):
            self.transactions.cancel_order(oid)
        self._stop_order_ids.clear()
        self._trading_disabled_today = True

    def _daily_reset(self) -> None:
        self._adaptive_learning_stub()
        pnl = self.portfolio.total_profit - self._prev_total_profit
        self.log(f"[DailyReset] Realised P&L: {pnl:.2f}")

        self._prev_total_profit = self.portfolio.total_profit
        self._trading_disabled_today, self._signals, self._candidates = False, [], []
        self._position_scores = {s: sc for s, sc in self._position_scores.items()
                                 if self.portfolio[s].invested}

    # ------------------------------------------------------------------
    # 10. HELPERS
    # ------------------------------------------------------------------
    def _ensure_security(self, ticker: str) -> Symbol:
        for sym in self._added_symbols:
            if sym.value == ticker:
                return sym
        sec = self.add_equity(ticker, Resolution.MINUTE,
                             data_normalization_mode=DataNormalizationMode.RAW)
        self._added_symbols.add(sec.symbol)
        return sec.symbol

    def _position_size(self, symbol: Symbol) -> int:
        price = self.securities[symbol].price
        return int(self._config["dollar_per_trade"] / price) if price > 0 else 0

    def _worst_profitable_position(self):
        worst_sym, worst_score = None, float("inf")
        for sym, score in self._position_scores.items():
            if self.portfolio[sym].invested and self.portfolio[sym].unrealized_profit >= 0 and score < worst_score:
                worst_sym, worst_score = sym, score
        return worst_sym, worst_score

    @staticmethod
    def _parse_score(tag: str) -> float:
        if "Score:" in tag:
            try:
                return float(tag.split("Score:")[1])
            except Exception:
                pass
        return 0.0

    # ------------------------------------------------------------------
    # 11. MOCK HOLLY/AZURE FEED   (replace with real Azure Blob call)
    # ------------------------------------------------------------------
    def _get_mock_holly_signals(self):
        return [
            {"ticker": "AAPL", "price": 150.0,  "rvol": 3.5, "score": 95},
            {"ticker": "MSFT", "price": 210.0,  "rvol": 2.4, "score": 90},
            {"ticker": "TSLA", "price": 700.0,  "rvol": 2.8, "score": 92},
            {"ticker": "GME",  "price": 20.0,   "rvol": 4.2, "score": 70},
            {"ticker": "AMZN", "price": 3300.0, "rvol": 2.1, "score": 88},
            {"ticker": "NVDA", "price": 190.0,  "rvol": 2.6, "score": 89},
        ]

    # ------------------------------------------------------------------
    # 12. SELF-LEARNING STUB (adaptive parameter tweak)
    # ------------------------------------------------------------------
    def _adaptive_learning_stub(self) -> None:
        pnl = self.portfolio.total_profit - self._prev_total_profit
        t_pct = self._config["trailing_stop_percent"]
        if pnl < 0:
            self._config["trailing_stop_percent"] = max(0.02, t_pct - 0.005)
            self.log(f"[Learn] Loss day – trail tightened to {self._config['trailing_stop_percent']:.3f}")
        elif pnl > 0.5 * self._config["daily_profit_target"]:
            self._config["trailing_stop_percent"] = min(0.05, t_pct + 0.005)
            self.log(f"[Learn] Strong day – trail loosened to {self._config['trailing_stop_percent']:.3f}")

This code sets up premarket analysis, intraday-only entry, robust risk/eviction logic, daily guards, rotation, logging, and the foundation for Azure/Holly integration and self-learning tweaks, as required by Robert's brief.

Sources: True Beats - QuantConnect.com, Empty Equity And Options400 Benchmark, docs writing algorithms portfolio key concepts, docs writing algorithms reality modeling buying power, Logging - QuantConnect.com