First Commit

Author: QuantGeekDev

.gitignore

@@ -0,0 +1,8 @@
+from pinescriptgen_core.flask_app import app
+
+# Punto de entrada principal para la app.
+# No se debe iniciar la app desde ningun otro archivo que no sea este
+
+
+if __name__ == '__main__':
+    app.run(debug=True, port=251)

.idea/.gitignore

@@ -0,0 +1,90 @@
+//@version=5
+strategy("Optimizer v1", overlay=true)
+
+// Conditions LONG EMA, SMA, PRICE
+ema70 = ta.ema(close, 70)
+ema100 = ta.ema(close, 100)
+
+cond_EMA1 = 0
+if ema70 > ema100 and ta.crossover(close, ema70)
+    cond_EMA1 := 1
+
+// Conditions LONG PRICE
+sma70 = ta.sma(close, 70)
+cond_EMA2 = 0
+if close > sma70
+    cond_EMA2 := 1
+
+// Conditions LONG ADX
+adxlen = 14
+dilen = 14
+dirmov(len) =>
+    up = ta.change(high)
+    down = -ta.change(low)
+    plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
+    minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
+    truerange = ta.rma(ta.tr, len)
+    plus = fixnan(100 * ta.rma(plusDM, len) / truerange)
+    minus = fixnan(100 * ta.rma(minusDM, len) / truerange)
+    [plus, minus]
+adx(dilen, adxlen) =>
+    [plus, minus] = dirmov(dilen)
+    sum = plus + minus
+    adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
+    adx
+sig = adx(dilen, adxlen)
+cond_dmi = 0
+if sig > 15
+    cond_dmi := 1
+//Conditions LONG CCI
+
+cci = ta.cci(close, 14) /// CCI LENGTH AGREGAR AL CODIGO
+cond_cci = 0
+if cci > 30
+    cond_cci := 1
+
+// Conditions LONG DMI, MACD , RSI'
+len = 14
+up = ta.change(high)
+down = -ta.change(low)
+truerange = ta.rma(ta.tr, len)
+plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
+minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
+
+[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)
+cond_macd = 0
+if histLine > 0
+    cond_macd := 1
+
+
+if cond_EMA1 and cond_EMA2 and cond_dmi and cond_cci and cond_macd
+    strategy.entry("Long", strategy.long)
+
+// B3 🟡Take Profit
+tp1_lot = 25 * strategy.position_size * 0.01
+tp2_lot = 25 * strategy.position_size * 0.01
+tp3_lot = 100 * strategy.position_size * 0.01
+stop_loss_price = 0.0
+tp1 = 0.0
+tp2 = 0.0
+tp3 = 0.0
+if strategy.position_size > 0// B4 🟡Stop Loss %
+    stop_loss_percent = 3
+    stop_loss_price := strategy.position_avg_price * 0.97 //(1 - stop_loss_percent / 100)
+    tp1 := strategy.position_avg_price * (1.01)
+    tp2 := strategy.position_avg_price * (1.02)
+    tp3 := strategy.position_avg_price * (1.03)
+    // strategy.exit("Stop Loss", "Long", stop=stop_loss_price)
+    strategy.exit("TP1", "Long", qty=tp1_lot, limit=tp1, stop=stop_loss_price)
+    strategy.exit("TP2", "Long", qty=tp2_lot, limit=tp2, stop=stop_loss_price)
+    strategy.exit("TP3", "Long", qty=tp3_lot, limit=tp3, stop=stop_loss_price)
+
+
+
+
+
+plot(stop_loss_price ? stop_loss_price : na, "stop_loss_price", color = color.red, style = plot.style_circles)
+
+plot(tp1 ? tp1 : na, "tp1", color = color.green, style = plot.style_circles)
+plot(tp2 ? tp2 : na, "tp2", color = color.green, style = plot.style_circles)
+plot(tp3 ? tp3 : na, "tp3", color = color.green, style = plot.style_circles)

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,20 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import Optional
+import logging
+from pinescriptgen_core.indicators import AbstractIndicator
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AbstractCondition:
+    """ Abstract Base Class para Condition"""
+
+
+@dataclass
+class Condition(AbstractCondition):
+    """Concrete Condition"""
+    condition: Optional[str]
+    indicatorA: Optional[AbstractIndicator] = None
+    indicatorB: Optional[AbstractIndicator] = None

.idea/mi_proyecto.iml

@@ -0,0 +1,24 @@
+from flask import Flask, request, render_template
+from pinescriptgen_core.pinescriptgenerator import PineScriptGenerator
+from pinescriptgen_core.formhandler import FormHandler
+import logging
+
+logging.basicConfig(level=logging.INFO, format='[%(asctime)s] %(levelname)s: %(message)s')
+
+app = Flask(__name__)
+
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        form_handler = FormHandler(request.form)
+        form_handler.handle_form_input()
+        strategy = form_handler.strategy
+
+        pinescript_code = PineScriptGenerator.generate(strategy)
+
+        return render_template('generated.html', pine_code=pinescript_code)
+
+    return render_template('index.html')
+
+

.idea/misc.xml

@@ -0,0 +1,123 @@
+from pinescriptgen_core.strategy import Strategy
+from pinescriptgen_core.conditions import Condition
+from pinescriptgen_core.indicators import IndicatorFactory, Indicator
+
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class FormHandler:
+    def __init__(self, request_form):
+        self.request_form = request_form
+        self.strategy = Strategy()
+
+    def handle_form_input(self):
+        for i in range(4):
+            # Comprueba si hay valores en longEmaSma y los procesa
+            if f'longEmaSma_{i}_indicatorA' in self.request_form:
+                self._process_longEmaSma(i)
+        # Comprueba si hay valores en longPrice y los procesa
+        if "longPrice" in self.request_form:
+            self._process_longPrice()
+
+        # Comprueba si hay valores en longAdxCci y los procesa
+        for i in range(2):  # Since you have 2 sets of conditions for longAdxCci
+            if f'longAdxCci_{i}_indicator' in self.request_form:
+                self._process_longAdxCci(i)
+        if 'longDmi_indicatorA' in self.request_form:
+            self._process_longDmi()
+
+        for i in range(2):
+            if f'longRsiMacd_{i}_indicatorA' in self.request_form:
+                self._process_longRsiMacd(i)
+
+    def _process_longEmaSma(self, index):
+        indicatorA_value = self.request_form[f'longEmaSma_{index}_indicatorA']
+        valueA = self.request_form[f'longEmaSma_{index}_valueA']
+        condition_value = self.request_form[f'longEmaSma_{index}_condition']
+        indicatorB_value = self.request_form[f'longEmaSma_{index}_indicatorB']
+        valueB = self.request_form[f'longEmaSma_{index}_valueB']
+
+        # Check if any of the values are empty; if they are, skip this condition
+        if not (indicatorA_value and valueA and condition_value and indicatorB_value and valueB):
+            return
+
+        # Use the factory to create the indicators
+        indicator1 = IndicatorFactory.create_indicator(indicatorA_value, valueA)
+        indicator2 = IndicatorFactory.create_indicator(indicatorB_value, valueB)
+
+        # Create the Condition object
+        condition = Condition(condition_value, indicator1, indicator2)
+        self.strategy.add_long_condition(condition)
+
+    def _process_longPrice(self):
+        price = self.request_form.get('longPrice', '')
+        condition = self.request_form.get('longPrice_condition', '')
+        indicator_value = self.request_form.get('longPrice_indicator', '')
+        indicator_value_num = self.request_form.get('longPrice_indicatorValue', '')
+
+        # Check if any of the values are empty; if they are, skip this condition
+        if not (price and condition and indicator_value and indicator_value_num):
+            return
+
+        # If all values are non-empty, proceed with creating the Condition object
+        if price == 'price':
+            price = 'close'
+        price_indicator = Indicator(price)
+        other_indicator = Indicator(indicator_value, indicator_value_num)
+        price_condition = Condition(price_indicator, condition, other_indicator)
+        print(price_condition)
+        self.strategy.add_long_condition(price_condition)
+
+    def _process_longAdxCci(self, index):
+        indicator_value = self.request_form.get(f'longAdxCci_{index}_indicator', '')
+        condition = self.request_form.get(f'longAdxCci_{index}_condition', '')
+        value = self.request_form.get(f'longAdxCci_{index}_value', '')
+
+        # Check if any of the values are empty; if they are, skip this condition
+        if not (indicator_value and condition and value):
+            return
+
+        # If all values are non-empty, proceed with creating the Condition object
+        if indicator_value == 'adx':
+            condition_indicator = Indicator(indicator_value, value)
+            adx_cci_condition = Condition(condition_indicator, condition)
+        else:
+            condition_indicator = Indicator(indicator_value, value)
+            adx_cci_condition = Condition(condition_indicator, condition)
+        self.strategy.add_long_condition(adx_cci_condition)
+
+    def _process_longDmi(self):
+        indicatorA_value = self.request_form.get('longDmi_indicatorA', '')
+        condition_value = self.request_form.get('longDmi_condition', '')
+        indicatorB_value = self.request_form.get('longDmi_indicatorB', '')
+
+        # Check if any of the values are empty; if they are, skip this condition
+        if not (indicatorA_value and condition_value and indicatorB_value):
+            return
+
+        # If all values are non-empty, proceed with creating the Condition object
+        indicatorA = Indicator(indicatorA_value)
+        indicatorB = Indicator(indicatorB_value)
+        dmi_condition = Condition(indicatorA, condition_value, indicatorB)
+        print(dmi_condition)
+        self.strategy.add_long_condition(dmi_condition)
+
+    def _process_longRsiMacd(self, index):
+        indicatorA_value = self.request_form[f'longRsiMacd_{index}_indicatorA']
+        condition_value = self.request_form[f'longRsiMacd_{index}_condition']
+        indicatorB_value = self.request_form[f'longRsiMacd_{index}_indicatorB']
+        indicatorB_value_num = self.request_form[f'longRsiMacd_{index}_indicatorBValue']
+
+        # Check if any of the values are empty; if they are, skip this condition
+        if not (indicatorA_value and condition_value and indicatorB_value and indicatorB_value_num):
+            return
+
+        # If all values are non-empty, proceed with creating the Condition object
+        indicatorA = Indicator(indicatorA_value)
+        indicatorB = Indicator(indicatorB_value, indicatorB_value_num)
+        rsi_macd_condition = Condition(indicatorA, condition_value, indicatorB)
+        print(rsi_macd_condition)
+        self.strategy.add_long_condition(rsi_macd_condition)