pulse-tradingview 0.1.0__tar.gz

pulse_tradingview-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: pulse-tradingview
+Version: 0.1.0
+Summary: Connect TradingView alerts to any crypto exchange via PULSE Protocol — free alternative to 3Commas
+Author: PULSE Protocol
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/pulseprotocolorg-cyber/pulse-tradingview
+Project-URL: Repository, https://github.com/pulseprotocolorg-cyber/pulse-tradingview
+Keywords: tradingview,webhook,crypto,trading,binance,bybit,automation,pine-script,pulse
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: binance
+Requires-Dist: pulse-binance>=0.1.0; extra == "binance"
+Provides-Extra: bybit
+Requires-Dist: pulse-bybit>=0.1.0; extra == "bybit"
+Provides-Extra: kraken
+Requires-Dist: pulse-kraken>=0.1.0; extra == "kraken"
+Provides-Extra: okx
+Requires-Dist: pulse-okx>=0.1.0; extra == "okx"
+Provides-Extra: freqtrade
+Requires-Dist: pulse-freqtrade>=0.1.0; extra == "freqtrade"
+Provides-Extra: all
+Requires-Dist: pulse-binance>=0.1.0; extra == "all"
+Requires-Dist: pulse-bybit>=0.1.0; extra == "all"
+Requires-Dist: pulse-kraken>=0.1.0; extra == "all"
+Requires-Dist: pulse-okx>=0.1.0; extra == "all"
+Requires-Dist: pulse-freqtrade>=0.1.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=0.10; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"

pulse_tradingview-0.1.0/pulse_tradingview/__init__.py

@@ -0,0 +1,13 @@
+"""pulse-tradingview — connect TradingView alerts to any exchange via PULSE Protocol."""
+
+from pulse_tradingview.version import __version__
+from pulse_tradingview.converter import AlertConverter
+from pulse_tradingview.router import SignalRouter
+from pulse_tradingview.webhook import WebhookReceiver
+
+__all__ = [
+    "__version__",
+    "AlertConverter",
+    "SignalRouter",
+    "WebhookReceiver",
+]

pulse_tradingview-0.1.0/pulse_tradingview/cli.py

@@ -0,0 +1,222 @@
+"""pulse-tv CLI — start the TradingView webhook server."""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+
+from pulse_tradingview.converter import AlertConverter
+from pulse_tradingview.router import SignalRouter
+from pulse_tradingview.webhook import WebhookReceiver
+
+
+def setup_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+
+def load_config(path: str) -> dict:
+    if not os.path.exists(path):
+        return {}
+    with open(path) as f:
+        return json.load(f)
+
+
+def build_router(config: dict) -> SignalRouter:
+    router = SignalRouter()
+
+    if "binance" in config:
+        from pulse_binance import BinanceAdapter
+        c = config["binance"]
+        adapter = BinanceAdapter(
+            api_key=c["api_key"],
+            api_secret=c["api_secret"],
+            testnet=c.get("testnet", False),
+        )
+        router.add_adapter(adapter, "Binance")
+
+    if "bybit" in config:
+        from pulse_bybit import BybitAdapter
+        c = config["bybit"]
+        adapter = BybitAdapter(
+            api_key=c["api_key"],
+            api_secret=c["api_secret"],
+            testnet=c.get("testnet", False),
+        )
+        router.add_adapter(adapter, "Bybit")
+
+    if "kraken" in config:
+        from pulse_kraken import KrakenAdapter
+        c = config["kraken"]
+        adapter = KrakenAdapter(api_key=c["api_key"], api_secret=c["api_secret"])
+        router.add_adapter(adapter, "Kraken")
+
+    if "okx" in config:
+        from pulse_okx import OKXAdapter
+        c = config["okx"]
+        adapter = OKXAdapter(
+            api_key=c["api_key"],
+            api_secret=c["api_secret"],
+            passphrase=c["passphrase"],
+        )
+        router.add_adapter(adapter, "OKX")
+
+    if "freqtrade" in config:
+        from pulse_freqtrade import FreqtradeAdapter
+        c = config["freqtrade"]
+        adapter = FreqtradeAdapter(
+            url=c.get("url", "http://localhost:8080"),
+            username=c.get("username", "freqtrader"),
+            password=c["password"],
+        )
+        router.add_adapter(adapter, "Freqtrade")
+
+    # Confidence filter
+    min_confidence = config.get("min_confidence", 0.0)
+    if min_confidence > 0:
+        router.add_filter(lambda p: p.get("confidence", 1.0) >= min_confidence)
+
+    # Pair whitelist
+    pairs = config.get("pairs", [])
+    if pairs:
+        router.add_filter(lambda p: p.get("pair") in pairs)
+
+    return router
+
+
+def cmd_start(args):
+    """Start the webhook server."""
+    config = load_config(args.config)
+    setup_logging(args.verbose)
+
+    router = build_router(config)
+
+    if not router._adapters:
+        print("Warning: No exchanges configured. Signals will be logged but not executed.")
+        print(f"Create a config file: pulse-tv init --output {args.config}")
+
+    def on_signal(params):
+        print(
+            f"  Signal: {params.get('pair')} | {params.get('direction').upper()} | "
+            f"confidence={params.get('confidence', 1.0):.0%} | "
+            f"price={params.get('price', 'market')}"
+        )
+        return router.route(params)
+
+    receiver = WebhookReceiver(
+        port=args.port,
+        on_signal=on_signal,
+        secret=args.secret or config.get("secret"),
+    )
+
+    print(f"\npulse-tradingview v0.1.0")
+    print(f"Webhook server: http://0.0.0.0:{args.port}/")
+    print(f"Health check:   http://localhost:{args.port}/")
+    if router._adapters:
+        print(f"Exchanges:      {', '.join(name for name, _ in router._adapters)}")
+    print(f"\nIn TradingView → Alert → Webhook URL:")
+    print(f"  http://YOUR_PUBLIC_IP:{args.port}/\n")
+    print("Waiting for signals... (Ctrl+C to stop)\n")
+
+    receiver.start()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopping...")
+        receiver.stop()
+
+
+def cmd_init(args):
+    """Create a sample config file."""
+    sample = {
+        "binance": {
+            "api_key": "YOUR_BINANCE_API_KEY",
+            "api_secret": "YOUR_BINANCE_API_SECRET",
+            "testnet": False
+        },
+        "min_confidence": 0.7,
+        "pairs": ["BTC/USDT", "ETH/USDT", "SOL/USDT"],
+        "secret": "optional-shared-secret-for-security"
+    }
+    output = args.output or "pulse_tv_config.json"
+    with open(output, "w") as f:
+        json.dump(sample, f, indent=2)
+    print(f"Created: {output}")
+    print("Edit it to add your exchange API keys and remove exchanges you don't use.")
+
+
+def cmd_test(args):
+    """Send a test signal to a running webhook server."""
+    import urllib.request
+
+    payload = json.dumps({
+        "action": args.action,
+        "symbol": args.symbol.replace("/", ""),
+        "price": str(args.price) if args.price else "0",
+        "interval": "1h",
+        "confidence": str(args.confidence),
+    }).encode()
+
+    url = f"http://localhost:{args.port}/"
+    req = urllib.request.Request(
+        url, data=payload,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5) as r:
+            result = json.loads(r.read())
+            print(f"Response: {json.dumps(result, indent=2)}")
+    except Exception as e:
+        print(f"Error: {e}")
+        print(f"Is the server running? Start it with: pulse-tv start")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pulse-tv",
+        description="TradingView webhook server for PULSE Protocol.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # start
+    start_p = subparsers.add_parser("start", help="Start webhook server")
+    start_p.add_argument("--port", type=int, default=8888, help="Port (default: 8888)")
+    start_p.add_argument("--config", default="pulse_tv_config.json", help="Config file")
+    start_p.add_argument("--secret", help="Shared secret for webhook validation")
+    start_p.add_argument("--verbose", "-v", action="store_true")
+
+    # init
+    init_p = subparsers.add_parser("init", help="Create sample config")
+    init_p.add_argument("--output", help="Output file path")
+
+    # test
+    test_p = subparsers.add_parser("test", help="Send test signal to running server")
+    test_p.add_argument("--port", type=int, default=8888)
+    test_p.add_argument("--action", default="buy", choices=["buy", "sell", "close"])
+    test_p.add_argument("--symbol", default="BTC/USDT")
+    test_p.add_argument("--price", type=float)
+    test_p.add_argument("--confidence", type=float, default=0.9)
+
+    args = parser.parse_args()
+
+    if args.command == "start":
+        cmd_start(args)
+    elif args.command == "init":
+        cmd_init(args)
+    elif args.command == "test":
+        cmd_test(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

pulse_tradingview-0.1.0/pulse_tradingview/converter.py

@@ -0,0 +1,186 @@
+"""AlertConverter — converts TradingView webhook alerts to PULSE messages."""
+
+import json
+from typing import Any, Dict, Optional
+
+
+# Map TradingView action strings to PULSE directions
+ACTION_MAP = {
+    "buy": "long",
+    "long": "long",
+    "enter_long": "long",
+    "sell": "short",
+    "short": "short",
+    "enter_short": "short",
+    "close": "neutral",
+    "exit": "neutral",
+    "flat": "neutral",
+}
+
+# Map TradingView interval strings to standard labels
+INTERVAL_MAP = {
+    "1": "1m", "3": "3m", "5": "5m", "15": "15m", "30": "30m",
+    "45": "45m", "60": "1h", "120": "2h", "180": "3h", "240": "4h",
+    "1D": "1d", "1W": "1w", "1M": "1M",
+}
+
+
+class AlertConverter:
+    """Convert TradingView webhook JSON to PULSE message parameters.
+
+    TradingView sends alerts as JSON via HTTP POST. The exact format
+    depends on the alert message template the user sets up in Pine Script.
+
+    Supported alert formats:
+
+    1. Standard format (recommended):
+       {"action": "buy", "symbol": "BTCUSDT", "price": "83000",
+        "interval": "1h", "confidence": "0.85"}
+
+    2. Minimal format:
+       {"action": "buy", "symbol": "BTCUSDT"}
+
+    3. Pine Script strategy format:
+       {"action": "{{strategy.order.action}}", "symbol": "{{ticker}}",
+        "price": "{{close}}", "interval": "{{interval}}"}
+
+    4. Plain text (legacy):
+       "BUY BTCUSDT"
+
+    Example:
+        >>> converter = AlertConverter()
+        >>> params = converter.parse('{"action": "buy", "symbol": "BTCUSDT", "price": "83000"}')
+        >>> params["direction"]  # "long"
+        >>> params["pair"]       # "BTC/USDT"
+    """
+
+    def parse(self, raw: str) -> Dict[str, Any]:
+        """Parse a TradingView alert message into PULSE parameters.
+
+        Args:
+            raw: Raw alert body (JSON string or plain text)
+
+        Returns:
+            Dict with keys: pair, direction, price, interval, confidence,
+            symbol, source
+
+        Raises:
+            ValueError: If the alert cannot be parsed
+        """
+        raw = raw.strip()
+
+        # Try JSON first
+        if raw.startswith("{"):
+            try:
+                data = json.loads(raw)
+                return self._parse_json(data)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON in alert: {e}")
+
+        # Fallback: plain text "BUY BTCUSDT" or "SELL ETHUSDT 3500"
+        return self._parse_text(raw)
+
+    def _parse_json(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse structured JSON alert."""
+        # Action → direction
+        action_raw = str(data.get("action", data.get("side", ""))).lower().strip()
+        direction = ACTION_MAP.get(action_raw)
+        if not direction:
+            raise ValueError(
+                f"Unknown action '{action_raw}'. Use: buy, sell, long, short, close"
+            )
+
+        # Symbol → pair
+        symbol = str(data.get("symbol", data.get("ticker", ""))).upper().strip()
+        if not symbol:
+            raise ValueError("Alert missing 'symbol' field")
+        pair = self._symbol_to_pair(symbol)
+
+        # Price
+        price_raw = data.get("price", data.get("close", None))
+        price = float(price_raw) if price_raw is not None else None
+
+        # Interval
+        interval_raw = str(data.get("interval", data.get("timeframe", ""))).strip()
+        interval = INTERVAL_MAP.get(interval_raw, interval_raw) if interval_raw else None
+
+        # Confidence (0-1)
+        confidence_raw = data.get("confidence", data.get("strength", None))
+        if confidence_raw is not None:
+            confidence = float(confidence_raw)
+            if confidence > 1.0:
+                confidence = confidence / 100.0  # handle percentage format
+        else:
+            confidence = 1.0  # TradingView alerts are deterministic, full confidence
+
+        # Extra passthrough fields
+        extra = {
+            k: v for k, v in data.items()
+            if k not in ("action", "side", "symbol", "ticker", "price", "close",
+                         "interval", "timeframe", "confidence", "strength")
+        }
+
+        result = {
+            "pair": pair,
+            "symbol": symbol,
+            "direction": direction,
+            "confidence": confidence,
+            "source": "tradingview",
+        }
+        if price is not None:
+            result["price"] = price
+        if interval:
+            result["interval"] = interval
+        if extra:
+            result["extra"] = extra
+
+        return result
+
+    def _parse_text(self, text: str) -> Dict[str, Any]:
+        """Parse plain text alert like 'BUY BTCUSDT' or 'SELL ETHUSDT 3500'."""
+        parts = text.upper().split()
+        if len(parts) < 2:
+            raise ValueError(
+                f"Cannot parse alert text '{text}'. "
+                "Expected format: 'BUY BTCUSDT' or JSON"
+            )
+        action_raw = parts[0].lower()
+        direction = ACTION_MAP.get(action_raw)
+        if not direction:
+            raise ValueError(f"Unknown action '{parts[0]}'")
+
+        symbol = parts[1]
+        pair = self._symbol_to_pair(symbol)
+        price = float(parts[2]) if len(parts) > 2 else None
+
+        result = {
+            "pair": pair,
+            "symbol": symbol,
+            "direction": direction,
+            "confidence": 1.0,
+            "source": "tradingview",
+        }
+        if price is not None:
+            result["price"] = price
+        return result
+
+    def _symbol_to_pair(self, symbol: str) -> str:
+        """Convert exchange symbol to PULSE pair format.
+
+        BTCUSDT → BTC/USDT
+        ETHBTC  → ETH/BTC
+        BTC/USDT → BTC/USDT (already formatted)
+        """
+        if "/" in symbol:
+            return symbol
+
+        quotes = ["USDT", "USDC", "BUSD", "BTC", "ETH", "BNB", "EUR", "USD", "GBP"]
+        for quote in quotes:
+            if symbol.endswith(quote) and len(symbol) > len(quote):
+                base = symbol[: -len(quote)]
+                return f"{base}/{quote}"
+
+        # Fallback: split at 3/4 chars
+        if len(symbol) >= 6:
+            return f"{symbol[:3]}/{symbol[3:]}"
+        return symbol

pulse_tradingview-0.1.0/pulse_tradingview/router.py

@@ -0,0 +1,160 @@
+"""SignalRouter — routes PULSE signals to configured exchange adapters."""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SignalRouter:
+    """Route incoming TradingView signals to one or more exchange adapters.
+
+    Supports any PULSE-compatible adapter: pulse-binance, pulse-bybit,
+    pulse-kraken, pulse-okx, or pulse-freqtrade.
+
+    Example:
+        >>> from pulse_binance import BinanceAdapter
+        >>> router = SignalRouter()
+        >>> router.add_adapter(BinanceAdapter(api_key="...", api_secret="..."))
+        >>> router.route({"pair": "BTC/USDT", "direction": "long", "price": 83000})
+    """
+
+    def __init__(self):
+        self._adapters: List = []
+        self._filters: List = []
+
+    def add_adapter(self, adapter, name: Optional[str] = None) -> "SignalRouter":
+        """Add an exchange adapter to route signals to.
+
+        Args:
+            adapter: Any PULSE-compatible adapter (BinanceAdapter, BybitAdapter, etc.)
+            name: Optional label for logging
+
+        Returns:
+            Self for chaining.
+        """
+        label = name or getattr(adapter, "__class__", type(adapter)).__name__
+        self._adapters.append((label, adapter))
+        logger.info(f"Added adapter: {label}")
+        return self
+
+    def add_filter(self, fn) -> "SignalRouter":
+        """Add a filter function that can block signals.
+
+        The filter receives the parsed parameters dict and returns True to
+        allow the signal, False to drop it.
+
+        Example:
+            >>> router.add_filter(lambda p: p["confidence"] >= 0.8)
+            >>> router.add_filter(lambda p: p["pair"] in ["BTC/USDT", "ETH/USDT"])
+
+        Args:
+            fn: Callable that takes params dict and returns bool
+
+        Returns:
+            Self for chaining.
+        """
+        self._filters.append(fn)
+        return self
+
+    def route(self, params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Route a parsed signal to all configured adapters.
+
+        Args:
+            params: Parsed alert parameters from AlertConverter
+
+        Returns:
+            List of results from each adapter (one per adapter).
+        """
+        # Apply filters
+        for f in self._filters:
+            if not f(params):
+                logger.info(
+                    f"Signal filtered out: {params.get('pair')} {params.get('direction')} "
+                    f"(confidence={params.get('confidence')})"
+                )
+                return []
+
+        if not self._adapters:
+            logger.warning("No adapters configured — signal dropped")
+            return []
+
+        results = []
+        for label, adapter in self._adapters:
+            try:
+                result = self._send_to_adapter(adapter, params, label)
+                results.append({"adapter": label, "status": "ok", "result": result})
+                logger.info(
+                    f"Signal sent to {label}: {params.get('pair')} {params.get('direction')}"
+                )
+            except Exception as e:
+                logger.error(f"Error sending to {label}: {e}")
+                results.append({"adapter": label, "status": "error", "error": str(e)})
+
+        return results
+
+    def _send_to_adapter(self, adapter, params: Dict[str, Any], label: str):
+        """Send signal to a specific adapter using PULSE message format."""
+        # Import here to avoid circular imports
+        try:
+            from pulse.message import PulseMessage
+        except ImportError:
+            raise ImportError(
+                "pulse-protocol not installed. Run: pip install pulse-protocol"
+            )
+
+        direction = params.get("direction", "neutral")
+
+        # Build PULSE message
+        msg_params = {
+            "pair": params.get("pair", ""),
+            "direction": direction,
+            "confidence": params.get("confidence", 1.0),
+            "source": params.get("source", "tradingview"),
+        }
+        if "price" in params:
+            msg_params["price"] = params["price"]
+        if "interval" in params:
+            msg_params["interval"] = params["interval"]
+
+        # For exchange adapters: use ACT.TRANSACT.REQUEST for actual trades
+        # For signal-only flow: use ACT.RECOMMEND.ACTION
+        adapter_class = type(adapter).__name__
+
+        if direction == "neutral":
+            # Close/exit signal — use ACT.CANCEL if supported
+            msg = PulseMessage(
+                action="ACT.RECOMMEND.ACTION",
+                parameters=msg_params,
+                validate=False,
+            )
+        elif adapter_class in ("FreqtradeAdapter",):
+            # Freqtrade: inject as signal recommendation, not direct trade
+            msg = PulseMessage(
+                action="ACT.RECOMMEND.ACTION",
+                parameters=msg_params,
+                validate=False,
+            )
+        else:
+            # Direct exchange adapter: place trade
+            trade_params = {
+                "pair": params.get("pair", ""),
+                "symbol": params.get("symbol", ""),
+                "side": "BUY" if direction == "long" else "SELL",
+                "type": "MARKET",
+            }
+            if "price" in params:
+                trade_params["price"] = params["price"]
+
+            msg = PulseMessage(
+                action="ACT.TRANSACT.REQUEST",
+                parameters=trade_params,
+                validate=False,
+            )
+
+        # Connect if needed
+        if hasattr(adapter, "connect") and not getattr(adapter, "_connected", False):
+            adapter.connect()
+
+        response = adapter.send(msg)
+        return response.content if hasattr(response, "content") else response

pulse_tradingview-0.1.0/pulse_tradingview/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pulse_tradingview-0.1.0/pulse_tradingview/webhook.py

@@ -0,0 +1,153 @@
+"""WebhookReceiver — HTTP server that accepts TradingView alert webhooks."""
+
+import json
+import logging
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Callable, Optional
+
+from pulse_tradingview.converter import AlertConverter
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookReceiver:
+    """HTTP server that receives TradingView webhook alerts.
+
+    TradingView sends an HTTP POST to your webhook URL when an alert fires.
+    WebhookReceiver listens on a configurable port, parses the alert,
+    and calls your handler function.
+
+    Example:
+        >>> def handle(params):
+        ...     print(f"Signal: {params['pair']} {params['direction']}")
+        ...
+        >>> receiver = WebhookReceiver(port=8888, on_signal=handle)
+        >>> receiver.start()
+        >>> # Set TradingView webhook URL to: http://YOUR_IP:8888/
+        >>> receiver.stop()
+
+    Or use as a context manager:
+        >>> with WebhookReceiver(port=8888, on_signal=handle) as r:
+        ...     input("Press Enter to stop...")
+    """
+
+    def __init__(
+        self,
+        port: int = 8888,
+        on_signal: Optional[Callable] = None,
+        secret: Optional[str] = None,
+        host: str = "0.0.0.0",
+    ):
+        """
+        Args:
+            port: Port to listen on (default: 8888)
+            on_signal: Callback called with parsed params dict on each alert
+            secret: Optional shared secret for basic auth validation
+            host: Host to bind to (default: 0.0.0.0 = all interfaces)
+        """
+        self.port = port
+        self.host = host
+        self.on_signal = on_signal or (lambda params: None)
+        self.secret = secret
+        self._server: Optional[HTTPServer] = None
+        self._thread: Optional[threading.Thread] = None
+        self._converter = AlertConverter()
+
+    def start(self) -> None:
+        """Start the webhook server in a background thread."""
+        handler = self._make_handler()
+        self._server = HTTPServer((self.host, self.port), handler)
+        self._thread = threading.Thread(
+            target=self._server.serve_forever,
+            daemon=True,
+            name="pulse-tradingview-webhook",
+        )
+        self._thread.start()
+        logger.info(f"WebhookReceiver listening on {self.host}:{self.port}")
+        print(f"[pulse-tradingview] Webhook server started on port {self.port}")
+        print(f"[pulse-tradingview] Set TradingView webhook URL to: http://YOUR_SERVER_IP:{self.port}/")
+
+    def stop(self) -> None:
+        """Stop the webhook server."""
+        if self._server:
+            self._server.shutdown()
+            self._server = None
+        logger.info("WebhookReceiver stopped")
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *args):
+        self.stop()
+
+    def _make_handler(self):
+        """Create the HTTP request handler class."""
+        receiver = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self):
+                # Validate secret if configured
+                if receiver.secret:
+                    auth = self.headers.get("X-PULSE-Secret", "")
+                    if auth != receiver.secret:
+                        self.send_error(401, "Unauthorized")
+                        return
+
+                # Read body
+                content_length = int(self.headers.get("Content-Length", 0))
+                raw = self.rfile.read(content_length).decode("utf-8", errors="replace")
+
+                if not raw.strip():
+                    self.send_error(400, "Empty request body")
+                    return
+
+                # Parse alert
+                try:
+                    params = receiver._converter.parse(raw)
+                except ValueError as e:
+                    logger.error(f"Alert parse error: {e} | raw={raw[:200]}")
+                    self.send_error(400, str(e))
+                    return
+
+                # Log the incoming signal
+                logger.info(
+                    f"Alert received: {params.get('pair')} {params.get('direction')} "
+                    f"(confidence={params.get('confidence', 1.0):.0%})"
+                )
+
+                # Call handler
+                try:
+                    results = receiver.on_signal(params)
+                    response = {
+                        "status": "ok",
+                        "pair": params.get("pair"),
+                        "direction": params.get("direction"),
+                        "results": results if isinstance(results, list) else [],
+                    }
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(json.dumps(response).encode())
+                except Exception as e:
+                    logger.error(f"Handler error: {e}")
+                    self.send_error(500, str(e))
+
+            def do_GET(self):
+                """Health check endpoint."""
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({
+                    "status": "ok",
+                    "service": "pulse-tradingview",
+                    "version": "0.1.0",
+                    "message": "Webhook server is running. POST your TradingView alerts here.",
+                }).encode())
+
+            def log_message(self, fmt, *args):
+                # Route HTTP server logs through Python logging
+                logger.debug(f"HTTP: {fmt % args}")
+
+        return Handler

pulse_tradingview-0.1.0/pulse_tradingview.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: pulse-tradingview
+Version: 0.1.0
+Summary: Connect TradingView alerts to any crypto exchange via PULSE Protocol — free alternative to 3Commas
+Author: PULSE Protocol
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/pulseprotocolorg-cyber/pulse-tradingview
+Project-URL: Repository, https://github.com/pulseprotocolorg-cyber/pulse-tradingview
+Keywords: tradingview,webhook,crypto,trading,binance,bybit,automation,pine-script,pulse
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: binance
+Requires-Dist: pulse-binance>=0.1.0; extra == "binance"
+Provides-Extra: bybit
+Requires-Dist: pulse-bybit>=0.1.0; extra == "bybit"
+Provides-Extra: kraken
+Requires-Dist: pulse-kraken>=0.1.0; extra == "kraken"
+Provides-Extra: okx
+Requires-Dist: pulse-okx>=0.1.0; extra == "okx"
+Provides-Extra: freqtrade
+Requires-Dist: pulse-freqtrade>=0.1.0; extra == "freqtrade"
+Provides-Extra: all
+Requires-Dist: pulse-binance>=0.1.0; extra == "all"
+Requires-Dist: pulse-bybit>=0.1.0; extra == "all"
+Requires-Dist: pulse-kraken>=0.1.0; extra == "all"
+Requires-Dist: pulse-okx>=0.1.0; extra == "all"
+Requires-Dist: pulse-freqtrade>=0.1.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=0.10; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"

pulse_tradingview-0.1.0/pulse_tradingview.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+pulse_tradingview/__init__.py
+pulse_tradingview/cli.py
+pulse_tradingview/converter.py
+pulse_tradingview/router.py
+pulse_tradingview/version.py
+pulse_tradingview/webhook.py
+pulse_tradingview.egg-info/PKG-INFO
+pulse_tradingview.egg-info/SOURCES.txt
+pulse_tradingview.egg-info/dependency_links.txt
+pulse_tradingview.egg-info/entry_points.txt
+pulse_tradingview.egg-info/requires.txt
+pulse_tradingview.egg-info/top_level.txt
+tests/test_tradingview.py

pulse_tradingview-0.1.0/pulse_tradingview.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pulse_tradingview-0.1.0/pulse_tradingview.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pulse-tv = pulse_tradingview.cli:main

pulse_tradingview-0.1.0/pulse_tradingview.egg-info/requires.txt

@@ -0,0 +1,27 @@
+
+[all]
+pulse-binance>=0.1.0
+pulse-bybit>=0.1.0
+pulse-kraken>=0.1.0
+pulse-okx>=0.1.0
+pulse-freqtrade>=0.1.0
+
+[binance]
+pulse-binance>=0.1.0
+
+[bybit]
+pulse-bybit>=0.1.0
+
+[dev]
+pytest>=7.0
+build>=0.10
+twine>=4.0
+
+[freqtrade]
+pulse-freqtrade>=0.1.0
+
+[kraken]
+pulse-kraken>=0.1.0
+
+[okx]
+pulse-okx>=0.1.0

pulse_tradingview-0.1.0/pulse_tradingview.egg-info/top_level.txt

@@ -0,0 +1 @@
+pulse_tradingview

pulse_tradingview-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pulse-tradingview"
+version = "0.1.0"
+description = "Connect TradingView alerts to any crypto exchange via PULSE Protocol — free alternative to 3Commas"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+authors = [{ name = "PULSE Protocol" }]
+keywords = ["tradingview", "webhook", "crypto", "trading", "binance", "bybit", "automation", "pine-script", "pulse"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business :: Financial",
+]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.optional-dependencies]
+binance = ["pulse-binance>=0.1.0"]
+bybit = ["pulse-bybit>=0.1.0"]
+kraken = ["pulse-kraken>=0.1.0"]
+okx = ["pulse-okx>=0.1.0"]
+freqtrade = ["pulse-freqtrade>=0.1.0"]
+all = [
+    "pulse-binance>=0.1.0",
+    "pulse-bybit>=0.1.0",
+    "pulse-kraken>=0.1.0",
+    "pulse-okx>=0.1.0",
+    "pulse-freqtrade>=0.1.0",
+]
+dev = ["pytest>=7.0", "build>=0.10", "twine>=4.0"]
+
+[project.scripts]
+pulse-tv = "pulse_tradingview.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/pulseprotocolorg-cyber/pulse-tradingview"
+Repository = "https://github.com/pulseprotocolorg-cyber/pulse-tradingview"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pulse_tradingview*"]

pulse_tradingview-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pulse_tradingview-0.1.0/tests/test_tradingview.py

@@ -0,0 +1,368 @@
+"""Tests for pulse-tradingview."""
+
+import json
+import threading
+import time
+import urllib.request
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from pulse_tradingview import AlertConverter, SignalRouter, WebhookReceiver
+
+
+# --- AlertConverter tests ---
+
+class TestAlertConverter:
+    def setup_method(self):
+        self.converter = AlertConverter()
+
+    # JSON format tests
+    def test_parse_buy_json(self):
+        raw = '{"action": "buy", "symbol": "BTCUSDT", "price": "83000", "interval": "1h"}'
+        params = self.converter.parse(raw)
+        assert params["direction"] == "long"
+        assert params["pair"] == "BTC/USDT"
+        assert params["price"] == 83000.0
+        assert params["interval"] == "1h"
+        assert params["source"] == "tradingview"
+
+    def test_parse_sell_json(self):
+        params = self.converter.parse('{"action": "sell", "symbol": "ETHUSDT"}')
+        assert params["direction"] == "short"
+        assert params["pair"] == "ETH/USDT"
+
+    def test_parse_long_action(self):
+        params = self.converter.parse('{"action": "long", "symbol": "SOLUSDT"}')
+        assert params["direction"] == "long"
+
+    def test_parse_short_action(self):
+        params = self.converter.parse('{"action": "short", "symbol": "BTCUSDT"}')
+        assert params["direction"] == "short"
+
+    def test_parse_close_action(self):
+        params = self.converter.parse('{"action": "close", "symbol": "BTCUSDT"}')
+        assert params["direction"] == "neutral"
+
+    def test_parse_confidence(self):
+        params = self.converter.parse(
+            '{"action": "buy", "symbol": "BTCUSDT", "confidence": "0.85"}'
+        )
+        assert params["confidence"] == 0.85
+
+    def test_parse_confidence_percentage(self):
+        # Some users send confidence as 85 instead of 0.85
+        params = self.converter.parse(
+            '{"action": "buy", "symbol": "BTCUSDT", "confidence": "85"}'
+        )
+        assert params["confidence"] == 0.85
+
+    def test_default_confidence_is_1(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTCUSDT"}')
+        assert params["confidence"] == 1.0
+
+    def test_parse_ticker_field(self):
+        # TradingView uses {{ticker}} which sends as "ticker" key
+        params = self.converter.parse('{"action": "buy", "ticker": "BTCUSDT"}')
+        assert params["pair"] == "BTC/USDT"
+
+    def test_parse_with_extra_fields(self):
+        raw = '{"action": "buy", "symbol": "BTCUSDT", "rsi": "28", "strategy": "RSI_BB"}'
+        params = self.converter.parse(raw)
+        assert params["direction"] == "long"
+        assert "extra" in params
+        assert params["extra"]["rsi"] == "28"
+
+    # Symbol conversion tests
+    def test_symbol_btcusdt(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTCUSDT"}')
+        assert params["pair"] == "BTC/USDT"
+
+    def test_symbol_ethbtc(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "ETHBTC"}')
+        assert params["pair"] == "ETH/BTC"
+
+    def test_symbol_solusdt(self):
+        params = self.converter.parse('{"action": "sell", "symbol": "SOLUSDT"}')
+        assert params["pair"] == "SOL/USDT"
+
+    def test_symbol_already_formatted(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTC/USDT"}')
+        assert params["pair"] == "BTC/USDT"
+
+    def test_symbol_eur_pair(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTCEUR"}')
+        assert params["pair"] == "BTC/EUR"
+
+    # Interval tests
+    def test_interval_60_to_1h(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTCUSDT", "interval": "60"}')
+        assert params["interval"] == "1h"
+
+    def test_interval_1D(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTCUSDT", "interval": "1D"}')
+        assert params["interval"] == "1d"
+
+    def test_interval_passthrough(self):
+        params = self.converter.parse('{"action": "buy", "symbol": "BTCUSDT", "interval": "4h"}')
+        assert params["interval"] == "4h"
+
+    # Plain text format
+    def test_parse_plain_buy(self):
+        params = self.converter.parse("BUY BTCUSDT")
+        assert params["direction"] == "long"
+        assert params["pair"] == "BTC/USDT"
+
+    def test_parse_plain_sell_with_price(self):
+        params = self.converter.parse("SELL ETHUSDT 3500")
+        assert params["direction"] == "short"
+        assert params["price"] == 3500.0
+
+    def test_parse_plain_case_insensitive(self):
+        params = self.converter.parse("buy BTCUSDT")
+        assert params["direction"] == "long"
+
+    # Error cases
+    def test_invalid_action(self):
+        with pytest.raises(ValueError, match="Unknown action"):
+            self.converter.parse('{"action": "hold", "symbol": "BTCUSDT"}')
+
+    def test_missing_symbol(self):
+        with pytest.raises(ValueError, match="missing 'symbol'"):
+            self.converter.parse('{"action": "buy"}')
+
+    def test_invalid_json(self):
+        with pytest.raises(ValueError, match="Invalid JSON"):
+            self.converter.parse('{"action": "buy", broken}')
+
+    def test_plain_text_too_short(self):
+        with pytest.raises(ValueError):
+            self.converter.parse("BUY")
+
+
+# --- SignalRouter tests ---
+
+class TestSignalRouter:
+    def test_add_adapter(self):
+        router = SignalRouter()
+        mock = MagicMock()
+        router.add_adapter(mock, "test")
+        assert len(router._adapters) == 1
+
+    def test_route_calls_adapter(self):
+        router = SignalRouter()
+        mock_adapter = MagicMock()
+        mock_adapter.send.return_value = MagicMock(content={"result": "ok"})
+
+        with patch("pulse_tradingview.router.PulseMessage") if False else patch.object(
+            router, "_send_to_adapter", return_value={"result": "ok"}
+        ):
+            router.add_adapter(mock_adapter, "test")
+            results = router.route({
+                "pair": "BTC/USDT",
+                "symbol": "BTCUSDT",
+                "direction": "long",
+                "confidence": 0.9,
+                "source": "tradingview",
+            })
+
+        assert len(results) == 1
+        assert results[0]["status"] == "ok"
+
+    def test_filter_blocks_low_confidence(self):
+        router = SignalRouter()
+        mock = MagicMock()
+        router.add_adapter(mock, "test")
+        router.add_filter(lambda p: p["confidence"] >= 0.8)
+
+        results = router.route({
+            "pair": "BTC/USDT",
+            "direction": "long",
+            "confidence": 0.5,
+        })
+        assert results == []
+
+    def test_filter_allows_high_confidence(self):
+        router = SignalRouter()
+        mock = MagicMock()
+        router.add_adapter(mock, "test")
+        router.add_filter(lambda p: p["confidence"] >= 0.8)
+
+        with patch.object(router, "_send_to_adapter", return_value={}):
+            results = router.route({
+                "pair": "BTC/USDT",
+                "direction": "long",
+                "confidence": 0.9,
+            })
+        assert len(results) == 1
+
+    def test_pair_filter(self):
+        router = SignalRouter()
+        mock = MagicMock()
+        router.add_adapter(mock, "test")
+        router.add_filter(lambda p: p["pair"] in ["BTC/USDT", "ETH/USDT"])
+
+        results = router.route({"pair": "DOGE/USDT", "direction": "long", "confidence": 1.0})
+        assert results == []
+
+    def test_no_adapters_returns_empty(self):
+        router = SignalRouter()
+        results = router.route({"pair": "BTC/USDT", "direction": "long"})
+        assert results == []
+
+    def test_adapter_error_is_caught(self):
+        router = SignalRouter()
+        mock = MagicMock()
+        router.add_adapter(mock, "test")
+
+        with patch.object(router, "_send_to_adapter", side_effect=RuntimeError("API error")):
+            results = router.route({"pair": "BTC/USDT", "direction": "long", "confidence": 1.0})
+
+        assert len(results) == 1
+        assert results[0]["status"] == "error"
+        assert "API error" in results[0]["error"]
+
+    def test_chaining(self):
+        router = SignalRouter()
+        mock = MagicMock()
+        result = router.add_adapter(mock).add_filter(lambda p: True)
+        assert result is router
+
+
+# --- WebhookReceiver tests ---
+
+class TestWebhookReceiver:
+    def test_start_stop(self):
+        received = []
+        receiver = WebhookReceiver(port=18888, on_signal=lambda p: received.append(p))
+        receiver.start()
+        time.sleep(0.1)
+        receiver.stop()
+
+    def test_health_check(self):
+        receiver = WebhookReceiver(port=18889)
+        receiver.start()
+        time.sleep(0.1)
+
+        try:
+            req = urllib.request.Request("http://localhost:18889/")
+            with urllib.request.urlopen(req, timeout=2) as r:
+                data = json.loads(r.read())
+            assert data["status"] == "ok"
+            assert "pulse-tradingview" in data["service"]
+        finally:
+            receiver.stop()
+
+    def test_receives_alert(self):
+        received = []
+
+        def handler(params):
+            received.append(params)
+            return []
+
+        receiver = WebhookReceiver(port=18890, on_signal=handler)
+        receiver.start()
+        time.sleep(0.1)
+
+        try:
+            payload = json.dumps({
+                "action": "buy",
+                "symbol": "BTCUSDT",
+                "price": "83000",
+            }).encode()
+            req = urllib.request.Request(
+                "http://localhost:18890/",
+                data=payload,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=2) as r:
+                response = json.loads(r.read())
+
+            assert response["status"] == "ok"
+            assert len(received) == 1
+            assert received[0]["direction"] == "long"
+            assert received[0]["pair"] == "BTC/USDT"
+        finally:
+            receiver.stop()
+
+    def test_bad_payload_returns_400(self):
+        receiver = WebhookReceiver(port=18891)
+        receiver.start()
+        time.sleep(0.1)
+
+        try:
+            payload = b'{"action": "hold", "symbol": "BTCUSDT"}'
+            req = urllib.request.Request(
+                "http://localhost:18891/",
+                data=payload,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            try:
+                urllib.request.urlopen(req, timeout=2)
+                assert False, "Should have raised"
+            except urllib.error.HTTPError as e:
+                assert e.code == 400
+        finally:
+            receiver.stop()
+
+    def test_context_manager(self):
+        received = []
+        with WebhookReceiver(port=18892, on_signal=lambda p: received.append(p)):
+            time.sleep(0.05)
+            # Server should be running
+            req = urllib.request.Request("http://localhost:18892/")
+            with urllib.request.urlopen(req, timeout=2) as r:
+                data = json.loads(r.read())
+            assert data["status"] == "ok"
+
+
+# --- Integration test ---
+
+class TestIntegration:
+    def test_full_pipeline(self):
+        """TradingView alert → WebhookReceiver → AlertConverter → SignalRouter"""
+        routed = []
+
+        converter = AlertConverter()
+        router = SignalRouter()
+
+        def fake_send(adapter, params, label):
+            routed.append(params)
+            return {"result": "ok"}
+
+        mock_adapter = MagicMock()
+        router.add_adapter(mock_adapter, "test")
+        router._send_to_adapter = fake_send
+
+        def on_signal(params):
+            return router.route(params)
+
+        receiver = WebhookReceiver(port=18893, on_signal=on_signal)
+        receiver.start()
+        time.sleep(0.1)
+
+        try:
+            alerts = [
+                '{"action": "buy", "symbol": "BTCUSDT", "price": "83000", "confidence": "0.92"}',
+                '{"action": "sell", "symbol": "ETHUSDT", "price": "3500"}',
+            ]
+            for alert in alerts:
+                req = urllib.request.Request(
+                    "http://localhost:18893/",
+                    data=alert.encode(),
+                    headers={"Content-Type": "application/json"},
+                    method="POST",
+                )
+                with urllib.request.urlopen(req, timeout=2):
+                    pass
+
+            assert len(routed) == 2
+            assert routed[0]["direction"] == "long"
+            assert routed[0]["pair"] == "BTC/USDT"
+            assert routed[0]["confidence"] == 0.92
+            assert routed[1]["direction"] == "short"
+            assert routed[1]["pair"] == "ETH/USDT"
+        finally:
+            receiver.stop()