Documentation

Référence Deepwick Script

Deepwick Script est le langage des graphiques et des backtests de Deepwick. Il exécute un sous-ensemble de Pine Script : la plupart des fonctions ta.*, math.*, str.*, input.*, plot* et strategy.* fonctionnent telles quelles, et les lignes non prises en charge sont signalées avec leur ligne et leur colonne. Cette page recense tout ce que le moteur accepte aujourd'hui et ce qu'il n'accepte pas.

Première fois sur Deepwick ? Commencez par le guide pas à pas : Comment tester gratuitement une stratégie Pine Script.

Vous construisez une IA qui écrit du Deepwick Script ? Cette référence en un seul document Markdown.

Mis à jour: 2026-10-03

Langage

Deepwick Script exécute un sous-ensemble de Pine Script, y compris les enums, les types définis par l'utilisateur, les méthodes et les maps ; la ligne //@version n'est pas vérifiée. Un script s'exécute une fois par bougie, de la plus ancienne à la plus récente, et chaque variable conserve son historique.

Syntaxe	Ce que ça fait
`x = expr / x := expr`	Déclare une variable, puis réassigne-la avec :=. Un type facultatif (int, float, bool, string, color, series, simple, const, line, label) peut précéder le nom.
`var / varip`	S'initialise une seule fois sur la première bougie et conserve la valeur d'une bougie à l'autre. varip se comporte comme var, puisque les scripts s'exécutent sur des bougies closes.
`x[n]`	Opérateur d'historique : la valeur de x il y a n bougies (na avant la première bougie).
`if / else`	Blocs conditionnels, indentés de quatre espaces. if peut aussi s'utiliser comme expression.
`cond ? a : b`	Opérateur ternaire.
`switch`	Branchement multiple, avec ou sans valeur à comparer.
`for i = a to b [by step]`	Boucle comptée. break et continue sont pris en charge.
`while cond`	Boucle tant qu'une condition reste vraie.
`f(x, y) => expr`	Fonction définie par l'utilisateur, sur une ligne ou comme un bloc indenté dont la dernière expression est renvoyée. Chaque site d'appel conserve son propre état ta.*, comme dans Pine.
`[a, b] = f()`	Tuples : les fonctions peuvent renvoyer plusieurs valeurs, et les natives comme ta.macd() et ta.bb() le font.
`and / or / not`	Opérateurs logiques. Arithmétique : + - * / % ; comparaison : == != < <= > >=.

Déclarations

Syntaxe	Ce que ça fait
`indicator(title, shorttitle, overlay, precision)`	Déclare un indicateur : il se dessine sur le graphique et n'a rien à tester. study() est accepté comme alias.
`strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)`	Déclare une stratégie. Par défaut : initial_capital 100000, 1 contrat par ordre, commission 0, slippage 0 ticks, pyramiding 1. Les autres arguments, comme process_orders_on_close, sont ignorés.

Entrées

Les entrées apparaissent à côté de l'éditeur et dans les réglages de l'indicateur, pour les modifier sans toucher au code.

Syntaxe	Ce que ça fait
`input.int(defval, title, minval, maxval, step)`	Nombre entier.
`input.float(defval, title, minval, maxval, step)`	Nombre décimal.
`input.bool(defval, title)`	Case à cocher.
`input.string(defval, title, options)`	Texte, ou une liste d'options.
`input.session(defval, title)`	Une séance de trading comme "0930-1600", ou des jours comme "23456". Passez-la à session.ismarket() et aux autres prédicats session.*.
`input.source(defval, title)`	Une source de prix : open, high, low, close, hl2, hlc3, ohlc4 ou hlcc4.
`input.color(defval, title)`	Sélecteur de couleur.
`input(defval, title)`	Entrée générique ; le type suit la valeur par défaut.

Données et heure de la bougie

Les heures sont en millisecondes UTC. hour() et les autres fonctions de temps acceptent une heure facultative ; hour() accepte aussi un fuseau horaire issu d'une liste fixe de décalages, sans heure d'été.

Syntaxe	Ce que ça fait
`open, high, low, close, volume`	Prix et volume de la bougie courante.
`hl2, hlc3, ohlc4, hlcc4`	Moyennes de prix usuelles.
`bar_index, last_bar_index`	Indice de la bougie courante (0 est la plus ancienne) et de la dernière bougie.
`time, time_close`	Heure d'ouverture et de clôture de la bougie. En tant que fonctions — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — le début (ou la fin) de la bougie de temporalité supérieure qui contient celle-ci, ou na lorsque la bougie est hors séance. Séances : "HHMM-HHMM", aussi nocturnes, plusieurs fenêtres séparées par des virgules, jours facultatifs après deux-points (1 = dimanche … 7 = samedi), "24x7".
`timeframe.change(timeframe)`	Vrai sur la première bougie de chaque nouvelle période, p. ex. timeframe.change("D") sur la première bougie de chaque jour (les semaines commencent le lundi).
`timestamp(timezone?, year, month, day, hour, minute, second)`	Une heure en millisecondes à partir de ses composantes, ou d'une date en texte : timestamp("2026-01-05T09:30:00Z").
`dayofweek.sunday … dayofweek.saturday`	Constantes de jour à comparer avec dayofweek (1 … 7).
`session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket`	État de la séance. Ici les marchés traders presque en continu, donc chaque bougie est en séance ; isfirstbar / islastbar marquent la première et la dernière bougie de chaque jour UTC.
`year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second`	Parties du calendrier de l'heure de la bougie ; appelables aussi avec une heure, p. ex. hour(time, "America/New_York"). dayofweek : 1 = dimanche … 7 = samedi.
`barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime`	Où se situe le script dans l'historique des bougies.
`timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly`	La temporalité du graphique.
`syminfo.ticker, tickerid, mintick, pointvalue`	Le symbole du graphique, son pas de prix et sa valeur du point.

Analyse technique (ta.*)

Chaque site d'appel conserve son propre état, comme dans Pine : deux appels ta.ema() sur des lignes différentes sont deux moyennes indépendantes. Le résultat vaut na tant qu'il n'y a pas assez de bougies.

Syntaxe	Ce que ça fait
`ta.sma(source, length)`	Moyenne mobile simple.
`ta.ema(source, length)`	Moyenne mobile exponentielle.
`ta.rma(source, length)`	Moyenne mobile de Wilder, utilisée par le RSI et l'ATR.
`ta.wma(source, length)`	Moyenne mobile pondérée.
`ta.vwma(source, length)`	Moyenne mobile pondérée par le volume.
`ta.hma(source, length)`	Moyenne mobile de Hull.
`ta.linreg(source, length, offset)`	Valeur de la droite de régression linéaire.
`ta.vwap(source)`	Prix moyen pondéré par le volume, qui repart à 00:00 UTC chaque jour.
`ta.rsi(source, length)`	Indice de force relative, de 0 à 100.
`ta.macd(source, fastlen, slowlen, siglen)`	Renvoie [macd, signal, histogram].
`ta.stoch(source, high, low, length)`	Stochastique %K, de 0 à 100.
`ta.cci(source, length)`	Indice de canal des matières.
`ta.mfi(series, length)`	Indice de flux de monnaie.
`ta.wpr(length)`	Williams %R, de -100 à 0.
`ta.dmi(diLength, adxSmoothing)`	Renvoie [+DI, -DI, ADX].
`ta.supertrend(factor, atrPeriod)`	Renvoie [supertrend, direction] ; la direction vaut -1 dans une tendance haussière et 1 dans une tendance baissière.
`ta.sar(start, inc, max)`	SAR parabolique.
`ta.mom(source, length)`	Momentum : la source moins la source d'il y a length bougies.
`ta.roc(source, length)`	Taux de variation, en pourcentage.
`ta.change(source, length)`	Écart avec la valeur d'il y a length bougies (1 par défaut).
`ta.tr / ta.tr(handle_na)`	True range.
`ta.atr(length)`	Average true range (Wilder).
`ta.bb(series, length, mult)`	Bandes de Bollinger : renvoie [middle, upper, lower].
`ta.bbw(series, length, mult)`	Largeur des bandes de Bollinger : (upper - lower) / middle.
`ta.kc(series, length, mult)`	Canaux de Keltner : renvoie [middle, upper, lower], avec une moyenne exponentielle du true range.
`ta.stdev(source, length, biased)`	Écart-type.
`ta.variance(source, length, biased)`	Variance.
`ta.dev(source, length)`	Écart moyen absolu.
`ta.median(source, length)`	Médiane.
`ta.highest(source, length) / ta.highest(length)`	Valeur la plus haute sur length bougies (le high par défaut).
`ta.lowest(source, length) / ta.lowest(length)`	Valeur la plus basse sur length bougies (le low par défaut).
`ta.highestbars(source, length)`	Décalage par rapport au plus haut : 0 ou négatif.
`ta.lowestbars(source, length)`	Décalage par rapport au plus bas : 0 ou négatif.
`ta.rising(source, length)`	Vrai si la source est au-dessus de chacune de ses length valeurs précédentes.
`ta.falling(source, length)`	Vrai si la source est en dessous de chacune de ses length valeurs précédentes.
`ta.crossover(source1, source2)`	Vrai sur la bougie où source1 croise au-dessus de source2.
`ta.crossunder(source1, source2)`	Vrai sur la bougie où source1 croise en dessous de source2.
`ta.cross(source1, source2)`	Vrai sur un croisement dans les deux sens.
`ta.pivothigh(source, leftbars, rightbars)`	Le prix du pivot high, connu rightbars bougies après le pivot ; na sinon. La source est facultative (le high par défaut).
`ta.pivotlow(source, leftbars, rightbars)`	Le prix du pivot low, connu rightbars bougies après le pivot ; na sinon. La source est facultative (le low par défaut).
`ta.valuewhen(condition, source, occurrence)`	Valeur de la source sur la occurrence-ième bougie la plus récente où la condition était vraie.
`ta.barssince(condition)`	Nombre de bougies depuis la dernière fois où la condition était vraie.
`ta.cum(source)`	Total cumulé depuis la première bougie.

Autres temporalités (request.*)

Une temporalité supérieure est construite à partir des bougies du graphique lui-même : elle n'a besoin d'aucune donnée que le moteur n'a pas. La valeur d'une bougie de temporalité supérieure ne devient visible que sur la bougie du graphique APRÈS sa clôture : une bougie de 4h n'est jamais lisible depuis l'intérieur, et c'est ce qui garde un backtest honnête.

Syntaxe Ce que ça fait

request.security(symbol, timeframe, expression) Exécute expression sur une temporalité supérieure du MÊME symbole et renvoie la dernière valeur CLOSE. Fonctionne sur le symbole du graphique (ou syminfo.tickerid, ou un symbole vide) ; un autre symbole renvoie na, car le moteur ne détient que les bougies du graphique. Les temporalités acceptent la notation de Pine ("60", "240", "D", "W", "M") et celle de Deepwick ("1h", "4h", "1d"). L'expression peut être un appel ta.*, évalué sur la série de temporalité supérieure. Renvoie na tant qu'une telle bougie n'a pas clôturé.

request.security(..., lookahead) Accepté et ignoré. lookahead_on permettrait à un backtest de lire la bougie de temporalité supérieure en formation, ce qui serait de l'anticipation ; le moteur ne jette jamais un coup d'œil. gaps n'affecte que le tracé intra-bougie, sans objet ici.

Syntaxe	Ce que ça fait
`request.security(symbol, timeframe, expression)`	Exécute expression sur une temporalité supérieure du MÊME symbole et renvoie la dernière valeur CLOSE. Fonctionne sur le symbole du graphique (ou syminfo.tickerid, ou un symbole vide) ; un autre symbole renvoie na, car le moteur ne détient que les bougies du graphique. Les temporalités acceptent la notation de Pine ("60", "240", "D", "W", "M") et celle de Deepwick ("1h", "4h", "1d"). L'expression peut être un appel ta.*, évalué sur la série de temporalité supérieure. Renvoie na tant qu'une telle bougie n'a pas clôturé.
`request.security(..., lookahead)`	Accepté et ignoré. lookahead_on permettrait à un backtest de lire la bougie de temporalité supérieure en formation, ce qui serait de l'anticipation ; le moteur ne jette jamais un coup d'œil. gaps n'affecte que le tracé intra-bougie, sans objet ici.

Stratégies (strategy.*)

Les ordres au marché s'exécutent à l'ouverture de la bougie suivante. Les ordres stop et limit s'exécutent le long de la bougie : ouverture, puis l'extrême le plus proche de l'ouverture, puis l'autre extrême, puis la clôture. Si le prix ouvre un gap à travers un ordre, celui-ci s'exécute à l'ouverture. La commission est prélevée à chaque exécution ; le slippage s'applique aux exécutions au marché et stop.

Syntaxe	Ce que ça fait
`strategy.entry(id, direction, qty, limit, stop, comment)`	Ouvre ou augmente une position ; ordre au marché sauf si limit ou stop est indiqué.
`strategy.order(id, direction, qty, limit, stop, comment)`	Les mêmes arguments que strategy.entry().
`strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)`	Take-profit, stop-loss et stop suiveur d'une entrée : profit et perte en ticks, limit et stop en prix. trail_points est la distance en TICKS depuis le meilleur prix atteint ; trail_offset est le profit en ticks qu'il faut effacer avant que le stop suiveur ne s'arme. Le stop ne se resserre que en votre faveur et bouge sur des bougies CLOSES : une bougie ne peut donc jamais exécuter le stop qu'elle a elle-même fixé.
`strategy.close(id, comment, qty_percent)`	Ferme une entrée au marché à la bougie suivante.
`strategy.close_all(comment)`	Ferme toutes les positions ouvertes.
`strategy.cancel(id) / strategy.cancel_all()`	Annule les ordres en attente.
`strategy.position_size, position_avg_price`	Position courante (positive longue, négative courte) et son prix moyen.
`strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Détails de l'opération ouverte n (0 = la plus ancienne) ; na si elle n'existe pas. size est négatif sur les positions vendeuses. Ex. sortir après 10 bougies : bar_index - strategy.opentrades.entry_bar_index(0) >= 10.
`strategy.closedtrades.entry_bar_index(n), exit_bar_index, entry_price, exit_price, entry_time, exit_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Détails de l'opération fermée n (0 = la plus ancienne ; la dernière est strategy.closedtrades - 1).
`strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital`	Chiffres du compte.
`strategy.closedtrades, opentrades, wintrades, losstrades`	Nombre d'opérations.
`strategy.long, strategy.short`	Directions.
`strategy.fixed, strategy.cash, strategy.percent_of_equity`	Valeurs de default_qty_type.
`strategy.commission.percent, cash_per_order, cash_per_contract`	Valeurs de commission_type.

Tracés et alertes

Syntaxe	Ce que ça fait
`plot(series, title, color, linewidth, style)`	Dessine une série sur le graphique ou dans un panneau.
`plotshape(series, title, style, location, color, text)`	Dessine une forme sur les bougies où series est vraie.
`plotchar(series, title, char, location, color)`	Dessine un caractère sur les bougies où series est vraie.
`hline(price, title, color, linestyle)`	Ligne horizontale à un niveau fixe.
`fill(plot1, plot2, color)`	Remplit entre deux tracés ou deux hlines.
`bgcolor(color)`	Colore le fond de la bougie.
`barcolor(color)`	Colore la bougie elle-même.
`alertcondition(condition, title, message)`	Déclare une condition que vous pouvez transformer en alerte par email, Telegram, Discord ou webhook.
`plot.style_*`	line, linebr, stepline, histogram, columns, circles, cross, area.
`hline.style_*`	solid, dashed, dotted.
`shape.*`	triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
`location.*`	abovebar, belowbar, top, bottom, absolute.
`size.*`	auto, tiny, small, normal, large, huge. Accepté, mais les formes sont dessinées à une seule taille.

Lignes et cadres

Syntaxe	Ce que ça fait
`line.new(x1, y1, x2, y2, extend, color, style, width)`	Dessine une ligne entre deux indices de bougie et deux prix ; renvoie son id.
`line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width`	Modifie une ligne.
`line.delete(id)`	Supprime une ligne.
`box.new(left, top, right, bottom, border_color, bgcolor, extend)`	Dessine un rectangle ; renvoie son id.
`box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend`	Modifie un cadre.
`box.delete(id)`	Supprime un cadre.
`line.style_, box.style_`	solid, dashed, dotted.
`extend.*`	none, left, right, both.

Mathématiques, chaînes et couleurs

Syntaxe	Ce que ça fait
`math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)`	Arithmétique.
`math.max(...), math.min(...), math.avg(...)`	Sur un nombre quelconque de valeurs.
`math.sum(source, length)`	Somme sur les length dernières bougies.
`math.pi, math.e`	Constantes.
`na, na(x), nz(x, replacement), fixnan(x)`	La valeur manquante, un test pour elle, un substitut et la dernière valeur non-na.
`int(x), float(x), bool(x)`	Conversions.
`str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)`	Chaînes. str.format remplace {0}, {1}… par les arguments.
`color.new(color, transp), color.rgb(red, green, blue, transp)`	Construit une couleur ; la transparence va de 0 à 100.
`color.*`	red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

Tableaux (array.*)

Syntaxe	Ce que ça fait
`array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)`	Crée un tableau.
`array.get, set, insert, push, pop, shift, unshift`	Lit et modifie des éléments.
`array.size, first, last, sum, avg, min, max, stdev`	Taille et statistiques.

Maps et types définis par l'utilisateur

Les types définis par l'utilisateur et la collection `map.<fn>` sont pris en charge. Les deux sont des déclarations de premier niveau ; les méthodes d'instance sur une valeur s'écrivent `obj.method(args...)`.

Syntaxe	Ce que ça fait
`enum Name Member Member = N ...`	Déclaration d'enum de premier niveau. Les membres sans valeur s'incrémentent automatiquement depuis 0 ; les valeurs explicites peuvent être des nombres ou des chaînes. On y accède par `Name.Member` dans toute position d'expression. Les valeurs d'enum sont de simples nombres (ou chaînes) : elles fonctionnent avec les opérateurs de comparaison et avec `int()` sans conversion.
`type Name field1 field2: int field3 = default`	Type défini par l'utilisateur, de premier niveau. Les champs se listent un par ligne ; les parties `: type` et `= default` sont acceptées pour la compatibilité future mais pas encore validées. On le construit avec `Type.new(arg1, arg2, ...)` et on lit les champs avec `instance.field`.
`m = map.new<int, float>()`	Crée un map vide. Les arguments de type `<K, V>` sont acceptés mais ignorés à l'exécution.
`m = map.put(m, key, value)`	Définit une clé. Renvoie le map pour que les appels puissent être enchaînés ou réaffectés.
`v = map.get(m, key)`	Lit une valeur. Renvoie na si la clé est absente.
`n = map.size(m)`	Nombre d'entrées.
`keys = map.keys(m), values = map.values(m)`	Renvoie les clés ou les valeurs sous forme de tableau Pine (ordre d'insertion).
`map.contains(m, key), map.remove(m, key)`	Test d'appartenance et suppression. Les deux renvoient le map.

Pas encore pris en charge

Une fonction inconnue du moteur interrompt le script avec « Unknown function » et la ligne et la colonne.

Syntaxe	Ce que ça fait
`label.new(), table.new()`	Pas encore disponible. Les lignes et les cadres le sont.
`import, matrix.*, array.new<type>()`	Les bibliothèques, les matrices et les constructeurs de tableau typés ne sont pas encore implémentés.
`strategy.risk.*`	Les règles de risque (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) ne sont pas prises en charge. Les stops suiveurs dans strategy.exit() le sont : utilisez trail_points et trail_offset.

Questions

Deepwick Script est-il la même chose que Pine Script ?

Non. C'est le moteur propre de Deepwick, qui exécute un sous-ensemble de Pine Script : les fonctions de cette page. La plupart des appels ta.*, math.*, str.*, input.*, plot* et strategy.* s'exécutent tels quels ; les lignes non prises en charge sont signalées avec leur ligne et leur colonne. Deepwick n'est pas affiliée à TradingView ; Pine Script est une marque de TradingView, Inc.

Quelles fonctionnalités de Pine Script Deepwick Script prend-il en charge ?

Deepwick Script exécute un sous-ensemble de Pine Script, y compris les enums, les types définis par l'utilisateur (`type`), les déclarations de méthodes et la collection `map.*`. Pas encore implémentés : les bibliothèques (`import`), `matrix.*` et les constructeurs de tableau typés `array.new<type>()` ; l'éditeur les signale avec la ligne et la colonne exactes. La ligne //@version n'est pas vérifiée. Collez un script dans l'éditeur pour voir quelles lignes s'exécutent.

Deepwick prend-il en charge request.security() ?

Oui, pour une temporalité supérieure du symbole du graphique lui-même. request.security(syminfo.tickerid, "240", close) renvoie le dernier close 4h CLOS, et l'expression peut être un appel ta.*. Un autre symbole renvoie toujours na : le moteur ne détient que les bougies du graphique, et un chiffre plausible mais faux serait pire que pas de chiffre du tout.

Pourquoi request.security() renvoie-t-il na sur les premières bougies ?

Parce qu'aucune bougie de temporalité supérieure n'a encore clôturé. Une bougie de 4h ne devient lisible que sur la bougie du graphique qui suit sa clôture, et c'est précisément ce qui empêche un backtest de lire une bougie en cours de formation. Une fois qu'une bougie a clôturé, la valeur se répète jusqu'à la clôture de la suivante.

Comment les ordres de stratégie sont-ils exécutés dans un backtest ?

Les ordres au marché s'exécutent à l'ouverture de la bougie suivante. Les stops et les limites s'exécutent le long de la bougie (ouverture, extrême le plus proche, extrême le plus loin, clôture), et un ordre que le prix ouvre en gap s'exécute à l'ouverture. La commission est prélevée à chaque exécution et le slippage sur les exécutions au marché et stop, comme défini dans strategy() ; les deux valent zéro par défaut.

Où s'exécutent les scripts ?

Sur le graphique, dans votre navigateur, sur les bougies chargées dans le graphique. Les backtests enregistrés s'exécutent sur les serveurs de Deepwick, sur jusqu'à 5 000 bougies.