class AdaptiveMomentumStrategy(bt.Strategy):
    """
    Trading strategy based on adaptive composite momentum.

    Entry:
        - go long when momentum crosses above the selected signal average
        - go short when momentum crosses below the selected signal average

    Signal average selection:
        On every bar the strategy tests candidate signal periods on a rolling
        lookback window. It scores historical crossings by the forward return
        after `score_horizon` bars and uses the period with the best score.

    Risk:
        Fixed percent stop-loss is applied to every position. Optional take
        profit and trailing stop can be enabled through params.
    """

    params = dict(
        price_period=5,
        momentum_periods=(8, 13, 21, 34),
        endpoint_window=4,
        pattern_window=3,
        momentum_smooth_period=5,
        signal_periods=(5, 8, 13, 21, 34),
        score_lookback=160,
        score_horizon=5,
        min_score_trades=4,
        stake=1,
        allow_short=True,
        reverse_on_signal=True,
        stop_loss=0.02,
        take_profit=None,
        trailing_stop=None,
        printlog=False,
    )

    def __init__(self) -> None:
        self.momentum = AdaptiveCompositeMomentum(
            self.data.close,
            price_period=self.p.price_period,
            momentum_periods=self.p.momentum_periods,
            endpoint_window=self.p.endpoint_window,
            pattern_window=self.p.pattern_window,
            smooth_period=self.p.momentum_smooth_period,
        )

        self.order = None
        self.entry_price: float | None = None
        self.stop_price: float | None = None
        self.take_price: float | None = None
        self.best_signal: SignalChoice | None = None

        max_signal_period = max(int(p) for p in self.p.signal_periods)
        self._min_ready = (
            max(self.p.momentum_periods)
            + int(self.p.endpoint_window)
            + int(self.p.pattern_window)
            + int(self.p.momentum_smooth_period)
            + int(self.p.score_lookback)
            + int(self.p.score_horizon)
            + max_signal_period
            + 5
        )

    def next(self) -> None:
        if self.order:
            return

        if len(self) < self._min_ready:
            return

        self.best_signal = self._select_signal_average()
        momentum_now = float(self.momentum[0])
        signal_now = self.best_signal.value

        if self._exit_by_risk():
            return

        crossed_up = self._crossed_up(momentum_now, signal_now, self.best_signal.period)
        crossed_down = self._crossed_down(momentum_now, signal_now, self.best_signal.period)

        if not self.position:
            if crossed_up:
                self.order = self.buy(size=self.p.stake)
            elif crossed_down and self.p.allow_short:
                self.order = self.sell(size=self.p.stake)
            return

        if self.position.size > 0 and crossed_down and self.p.reverse_on_signal:
            target = -self.p.stake if self.p.allow_short else 0
            self.order = self.order_target_size(target=target)
        elif self.position.size < 0 and crossed_up and self.p.reverse_on_signal:
            self.order = self.order_target_size(target=self.p.stake)

    def notify_order(self, order: bt.Order) -> None:
        if order.status in (order.Submitted, order.Accepted):
            return

        if order.status == order.Completed:
            executed_price = float(order.executed.price)

            if self.position.size > 0:
                self.entry_price = float(self.position.price) or executed_price
                self._set_risk_levels(direction=1)
                self.log(f"LONG {self.entry_price:.5f}")
            elif self.position.size < 0:
                self.entry_price = float(self.position.price) or executed_price
                self._set_risk_levels(direction=-1)
                self.log(f"SHORT {self.entry_price:.5f}")
            else:
                self.entry_price = None
                self.stop_price = None
                self.take_price = None
                self.log(f"FLAT {executed_price:.5f}")

            if order.isbuy():
                self.log(f"BUY fill {executed_price:.5f}")
            elif order.issell():
                self.log(f"SELL fill {executed_price:.5f}")

        elif order.status in (order.Canceled, order.Margin, order.Rejected):
            self.log(f"Order failed: {order.getstatusname()}")

        self.order = None

    def notify_trade(self, trade: bt.Trade) -> None:
        if trade.isclosed:
            self.log(f"TRADE PNL gross={trade.pnl:.2f}, net={trade.pnlcomm:.2f}")
            if not self.position:
                self.entry_price = None
                self.stop_price = None
                self.take_price = None

    def _select_signal_average(self) -> SignalChoice:
        choices = [
            SignalChoice(period=int(period), value=self._signal_value(int(period), 0), score=self._score_signal_period(int(period)))
            for period in self.p.signal_periods
        ]
        return max(choices, key=lambda choice: choice.score)

    def _score_signal_period(self, period: int) -> float:
        start_ago = int(self.p.score_lookback) + int(self.p.score_horizon)
        end_ago = int(self.p.score_horizon) + 1

        score = 0.0
        trades = 0

        for ago in range(start_ago, end_ago, -1):
            mom_prev = float(self.momentum[-ago - 1])
            mom_now = float(self.momentum[-ago])
            sig_prev = self._signal_value(period, ago + 1)
            sig_now = self._signal_value(period, ago)

            close_now = float(self.data.close[-ago])
            close_future = float(self.data.close[-ago + int(self.p.score_horizon)])
            if close_now == 0:
                continue

            forward_return = (close_future - close_now) / close_now

            if mom_prev <= sig_prev and mom_now > sig_now:
                score += forward_return
                trades += 1
            elif mom_prev >= sig_prev and mom_now < sig_now:
                score -= forward_return
                trades += 1

        if trades < int(self.p.min_score_trades):
            return float("-inf")

        return score / trades

    def _signal_value(self, period: int, ago: int) -> float:
        values = [float(self.momentum[-ago - i]) for i in range(period)]
        return sum(values) / period

    def _crossed_up(self, momentum_now: float, signal_now: float, period: int) -> bool:
        momentum_prev = float(self.momentum[-1])
        signal_prev = self._signal_value(period, 1)
        return momentum_prev <= signal_prev and momentum_now > signal_now

    def _crossed_down(self, momentum_now: float, signal_now: float, period: int) -> bool:
        momentum_prev = float(self.momentum[-1])
        signal_prev = self._signal_value(period, 1)
        return momentum_prev >= signal_prev and momentum_now < signal_now

    def _set_risk_levels(self, direction: int) -> None:
        if self.entry_price is None:
            return

        stop_loss = self.p.stop_loss
        take_profit = self.p.take_profit

        if stop_loss:
            self.stop_price = self.entry_price * (1 - direction * float(stop_loss))
        if take_profit:
            self.take_price = self.entry_price * (1 + direction * float(take_profit))

    def _exit_by_risk(self) -> bool:
        if not self.position or self.entry_price is None:
            return False

        close = float(self.data.close[0])

        if self.p.trailing_stop:
            trail = float(self.p.trailing_stop)
            if self.position.size > 0:
                trail_stop = close * (1 - trail)
                self.stop_price = max(self.stop_price or trail_stop, trail_stop)
            else:
                trail_stop = close * (1 + trail)
                self.stop_price = min(self.stop_price or trail_stop, trail_stop)

        if self.position.size > 0:
            hit_stop = self.stop_price is not None and close <= self.stop_price
            hit_take = self.take_price is not None and close >= self.take_price
        else:
            hit_stop = self.stop_price is not None and close >= self.stop_price
            hit_take = self.take_price is not None and close <= self.take_price

        if hit_stop or hit_take:
            reason = "STOP" if hit_stop else "TAKE"
            self.log(f"{reason} close={close:.5f}")
            self.order = self.close()
            return True

        return False

    def log(self, text: str) -> None:
        if self.p.printlog:
            date = self.data.datetime.date(0).isoformat()
            print(f"{date} {text}")

Сенкс чел! 
Я только что стырил твою стратегию, еще правда не проверил насколько хорошо это работает! 

from __future__ import annotations

from dataclasses import dataclass
from typing import Iterable, Sequence

import backtrader as bt


@dataclass(frozen=True)
class SignalChoice:
    period: int
    value: float
    score: float


class AdaptiveCompositeMomentum(bt.Indicator):
    lines = ("momentum",)
    params = dict(
        price_period=5,
        momentum_periods=(8, 13, 21, 34),
        endpoint_window=4,
        pattern_window=3,
        normalize=True,
        smooth_period=5,
    )

    plotinfo = dict(subplot=True)
    plotlines = dict(momentum=dict(color="tab:blue"))

    def __init__(self) -> None:
        periods = tuple(int(p) for p in self.p.momentum_periods)
        self._periods = periods
        self._smoothed_price = bt.ind.SMA(self.data, period=int(self.p.price_period))
        self.addminperiod(
            int(self.p.price_period)
            + max(periods)
            + int(self.p.endpoint_window)
            + int(self.p.pattern_window)
            + int(self.p.smooth_period)
            + 2
        )

        self._raw_values: list[float] = []

    def next(self) -> None:
        current_slope = self._slope(0, int(self.p.pattern_window))
        parts: list[float] = []

        for period in self._periods:
            endpoint_ago = self._best_endpoint(period, current_slope)
            old_price = float(self._smoothed_price[-endpoint_ago])
            cur_price = float(self._smoothed_price[0])

            if self.p.normalize:
                value = 0.0 if old_price == 0 else (cur_price - old_price) / old_price
            else:
                value = cur_price - old_price

            parts.append(value)

        raw = sum(parts) / len(parts)
        self._raw_values.append(raw)

        smooth_period = int(self.p.smooth_period)
        if smooth_period <= 1 or len(self._raw_values) < smooth_period:
            self.lines.momentum[0] = raw
        else:
            self.lines.momentum[0] = sum(self._raw_values[-smooth_period:]) / smooth_period

    def _best_endpoint(self, period: int, current_slope: float) -> int:
        pattern_window = int(self.p.pattern_window)
        endpoint_window = int(self.p.endpoint_window)

        best_ago = period
        best_error = float("inf")

        for ago in range(max(pattern_window + 1, period - endpoint_window), period + endpoint_window + 1):
            historical_slope = self._slope(-ago, pattern_window)
            error = abs(current_slope - historical_slope)
            if error < best_error:
                best_error = error
                best_ago = ago

        return best_ago

    def _slope(self, index: int, window: int) -> float:
        start = float(self._smoothed_price[index])
        end = float(self._smoothed_price[index - window])
        base = abs(end) if end else 1.0
        return (start - end) / base

Тикер, Кол-во шагов и Бюджет на шаг перешли из первоначальной таблицы Free Trading Bot.

Изм. цены, % и Коррекция, мин перешли из Настроек во вкладку Акции для установки индивидуальных значений для каждого тикера.

Стратегия – можно внести К или Н. К – классическая, продаем все что купили. Н – набор, продаем на сумму не больше выделенного бюджета умноженного на количество шагов чтобы в портфеле со временем оставались лишние акции. Например при бюджете 1000 рублей вы купили 12 акций по 78 рублей на 936 рублей, цена акции выросла до 95 рублей, бот выставит на продажу по стратегии Набор только 10 акций на сумму 950 рублей, так как если бы он выставил все 12 купленных акций, то это было бы 1140 рублей что превышает 1000 рублей выделенного бюджета. По итогу у вас в портфеле осталось бы 2 акции и 14 рублей прибыли.

Торги в сб и вс – разрешение торговать в выходные для тех или иных акций.

Новый день – если «вчера» у бота не было исполненных заявок на покупку, то «сегодня» бот не будет продолжать повышать цену заявки для закупки, а начнет торговать сначала. При этом если «вчера» была исполненная заявка на покупку и бот выставил заявку на продажу, которая не была удовлетворена, то «сегодня» бот перевыставит заявку на продажу по первоначальной цене с которой начинал «вчера» понижение цены продажи, заявка на покупку же продолжит расти от цены последней заявки на покупку предыдущего дня.

Прогрессия – это увеличение бюджета на шаг с увеличением количества шагов. 0 – без применения прогрессии, 1 – каждый следующий закуп больше на предыдущего на 1 бюджет (100, 200, 300, 400...), более 1 или менее 1, любое число, например 1.5, 2.2, 0.9, 13 – при этом каждое следующее изменение бюджета становится кратным введенному числу.
Пример при введенной 2: 100, 200, 400, 800...
Пример при введенной 1.5: 100, 150, 225, 337.5...
Пример при введенной 0.5: 1000, 500, 250, 125...

Автокоррекция – это разрешение роботу автоматически корректировать параметры «Изм. цены, %» и «Коррекция, мин». Подробнее как это работает описано в отдельном шаге курса в Битве настроек.

Производство двигателей ПД-14 стартовало в январе 2020 года, в этом месяце первые пробные двигатели были поставлены на Иркутский авиазавод. На этот же год было запланировано завершение сертификации, а запуск серийного производства — на 2021-й год^.

В 2023 году Объединенная двигателестроительная корпорация (ОДК, входит в «Ростех») сообщила, что планирует начать серийное производство двигателей в текущем году, а в 2030 году доведёт их выпуск до 160 штук^[32].

Всего на конец октября 2023 года было изготовлено 8 двигателей ПД-14, а начало серийного производства было перенесено на 2024 год^[33].

До ноября 2024 года Объединенная двигателестроительная корпорация (ОДК) передала заказчикам только два мотора ПД-14, хотя в октябре 2023-го генеральный конструктор «ОДК-Авиадвигатели» Александр Иноземцев докладывал Владимиру Путину о намерении выпустить в этом году 12 силовых установок ПД-14, а в 2025-м — 24. Планы на 2025 год сократились до семи единиц

Исполнение федерального бюджета за январь-апрель 2026 год

(предварительные данные)

млрд рублей

Ниже приведено сравнение медианной заработной платы и цен на бензин марки АИ-95 в России за 2005 и 2025 годы.Зарплата и цены: 2005 vs 2025

Показатель [1, 2, 3, 4, 5, 6]	2005 год	2025 год	Изменение
Медианная зарплата	~5 500 – 6 000 руб.	~73 400 – 74 000 руб.	Рост в ~12,5 раз
Цена бензина АИ-95	~17,92 руб./литр	~67,00 – 68,70 руб./литр	Рост в ~3,8 раза

 Поэтому каждый раз, когда слышишь очередной крик «пузырь!» — стоит задать простой вопрос: а байбеки в расчёт брались?

Но падение на 20–30% не будет схлопыванием пузыря. Это будет обычная коррекция внутри нормально работающего рынка. При этом в 2008 году в акциях США не было пузыря, а до пузыря 2000-го года рынку нужно вырасти еще минимум на 50-70%.

Скоро мне исполнится 34, и можно сказать, что практически половину жизни я провёл рядом с рынками. За эти годы понял одну важную вещь: нет никакой прямой корреляции между количеством проведённого на рынках времени и итоговой доходностью. Как нет её и между объёмом знаний и результатом.

Почему-то опять хочется затронуть малую толику бюджета и инфляции.)

Сфера услуг, включая торговлю это 60+% ВВП РФ.

Оборот торгового и интернет экварийнга в торговле и сфере услуг огромен, а средняя итоговая комиссия для бизнеса сейчас думаю порядка 2% с НДС с учетом применения льготных ставок от оборота, преференцированных MCC и системы QR.

Эти 2% комиссии состоят, грубо говоря, из 1,16% интерчейнджа(межбанковская комиссия в пользу банка-эмитента), НСПК(он же ЦБ) забирает 0,1-0,2%, 0,34 комиссии банка-эквайера и 22% НДС.

Субьектам МСП комиссия и вовсе сейчас обходится в 2,5+% безналичной выручки в пользу банков и госбюджета.

Основными оператором рынка эквайринга является СБ и, в том числе ВТБ, из которых государство налогами и дивидендами вынимает в бюджет добрую половину комиссии и 22% НДС напрямую.

Таким образом эквайринг является не просто одним из оборотных налогов, а попросту легализованным грабежом бизнеса и населения. Только населению иногда возвращают кэшбек.

Ну и разумеется в целом оборотная комиссия такого обьема это существенный проинфляционный фактор, вполне сопоставимый с повышением НДС на 2%, фактически налог с безналичных продаж.

Вот сидели вы в мастерской и усердно лепили глиняные горшки, а потом херак и у вас просто так отжали 2,5% вашего труда. При этом тот же годовой лимит выручки не уменьшается на размер комиссии и является базой для расчета и уплаты налогов.))

А потом вам повышают налоги и предлагают ваши же деньги кредитом под 25% годовых, да даже если под 10. И все платят и молчат...)

2) Политика без неё не будет спекулятивных покупок, а продажи мы уже видели. Сейчас можно с уверенностью сказать, что США нам оказали медвежью услугу в переговорах и чтобы это лед действительно тронулся надо разговаривать с Европой и идти на уступки без этого деньги от нерезов не поступят. Да и Евроклир держит за яйца наших инвесторов.

Президент Республики Абхазия Бадра Гунба с супругой

Президент Республики Беларусь Александр Лукашенко

Президент Лаосской Народно-Демократической Республики Тхонглун Сисулит

Верховный правитель Малайзии султан Ибрагим

Председатель Правительства Словацкой Республики Роберт Фицо

Президент Республики Южная Осетия Алан Гаглоев

Президент Республики Сербской (Босния и Герцеговина) Синиша Каран

Сенкс, чел! 

Сделал новенький индикатор из твоей формулы

import backtrader as bt


class WeightedPriceDelta(bt.Indicator):
    """
    Weighted average of price plus one-bar and two-bar price changes.

    Formula:
        Y = 0.75 * Sum((P(i) - P(i-1)) + P(i), n) / n
          + 0.25 * Sum((P(i) - P(i-2)) + P(i), n) / n
    """

    lines = ("y",)
    params = dict(period=14)

    plotinfo = dict(subplot=False)
    plotlines = dict(y=dict(color="tab:blue"))

    def __init__(self) -> None:
        period = int(self.p.period)
        if period <= 0:
            raise ValueError("period must be positive")

        one_bar_component = (self.data - self.data(-1)) + self.data
        two_bar_component = (self.data - self.data(-2)) + self.data

        one_bar_average = bt.ind.SumN(one_bar_component, period=period) / period
        two_bar_average = bt.ind.SumN(two_bar_component, period=period) / period

        self.lines.y = 0.75 * one_bar_average + 0.25 * two_bar_average
        self.addminperiod(period + 2)