pybynix 1.0.0__py3-none-any.whl

pybynix/__init__.py

@@ -0,0 +1,79 @@
+"""Unofficial Bynix SDK. No affiliation with the platform or Python Software Foundation."""
+
+from .auth import AuthChain, BrowserAuth, PasswordAuth, SessionProvider, load_session, save_session
+from .client import Bynix
+from .data import candles_to_dataframe, candles_to_records, export_candles, resample_candles
+from .indicators import (
+    BollingerBandsResult,
+    MACDResult,
+    StochasticResult,
+    atr,
+    average_true_range,
+    bollinger_bands,
+    ema,
+    exponential_moving_average,
+    macd,
+    moving_average_convergence_divergence,
+    relative_strength_index,
+    rsi,
+    simple_moving_average,
+    sma,
+    stochastic,
+    stochastic_oscillator,
+)
+from .journal import MemoryJournal, SQLiteJournal
+from .models import AccountType, Candle, ConnectionEvent, Session, Tick
+from .orchestration import (
+    AutoExecutor,
+    DecisionCallback,
+    ExecutionIntent,
+    ExecutionOrchestrator,
+    ExecutionRecord,
+    OrderIntent,
+)
+from .pool import ClientPool
+
+__version__ = "1.0.0"
+__all__ = [
+    "AccountType",
+    "AuthChain",
+    "BollingerBandsResult",
+    "BrowserAuth",
+    "Bynix",
+    "Candle",
+    "ClientPool",
+    "ConnectionEvent",
+    "AutoExecutor",
+    "DecisionCallback",
+    "ExecutionIntent",
+    "ExecutionOrchestrator",
+    "ExecutionRecord",
+    "MemoryJournal",
+    "MACDResult",
+    "PasswordAuth",
+    "SQLiteJournal",
+    "Session",
+    "SessionProvider",
+    "StochasticResult",
+    "Tick",
+    "OrderIntent",
+    "candles_to_dataframe",
+    "candles_to_records",
+    "export_candles",
+    "load_session",
+    "atr",
+    "average_true_range",
+    "bollinger_bands",
+    "ema",
+    "exponential_moving_average",
+    "macd",
+    "moving_average_convergence_divergence",
+    "relative_strength_index",
+    "resample_candles",
+    "rsi",
+    "save_session",
+    "simple_moving_average",
+    "sma",
+    "stochastic",
+    "stochastic_oscillator",
+]

pybynix/auth.py

@@ -0,0 +1,207 @@
+"""Explicit session, credential and browser providers. No implicit browser launch."""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Protocol
+
+import httpx
+
+from .errors import AuthenticationError, ChallengeRequired, ProtocolError, RateLimitError
+from .models import LoginChallenge, Session
+from .network import DNSHTTPTransport, validate_dns, validate_dns_servers
+
+
+class SessionProvider(Protocol):
+    async def __call__(self, host: str) -> Session: ...
+
+
+class PasswordAuth:
+    def __init__(
+        self,
+        email: str,
+        password: str,
+        *,
+        proxy=None,
+        dns_overrides=None,
+        otp_callback=None,
+        dns_servers=(),
+        dns_port=53,
+    ):
+        self._email, self._password = email, password
+        if proxy and (dns_overrides or dns_servers):
+            raise ValueError("Use proxy or static DNS overrides, not both")
+        self._proxy = proxy
+        self._dns = validate_dns(dns_overrides)
+        self._dns_servers = validate_dns_servers(dns_servers)
+        self._dns_port = dns_port
+        self._otp_callback = otp_callback
+
+    async def __call__(self, host: str) -> Session:
+        try:
+            async with httpx.AsyncClient(
+                timeout=30,
+                follow_redirects=False,
+                trust_env=False,
+                proxy=self._proxy,
+                transport=DNSHTTPTransport(
+                    self._dns, nameservers=self._dns_servers, port=self._dns_port
+                )
+                if self._dns or self._dns_servers
+                else None,
+            ) as http:
+                response = await http.post(
+                    f"https://{host}/api/auth/login",
+                    json={"email": self._email, "password": self._password},
+                )
+        except httpx.TransportError:
+            raise ProtocolError("Login transport failed") from None
+        if not response.is_success:
+            if response.status_code == 429:
+                raise RateLimitError(response.headers.get("Retry-After"))
+            if response.status_code == 403:
+                try:
+                    failure = response.json()
+                except ValueError:
+                    failure = {}
+                if (
+                    response.headers.get("cf-mitigated") == "challenge"
+                    or isinstance(failure, dict)
+                    and failure.get("code")
+                    in {"challenge_required", "captcha_required", "turnstile_required"}
+                ):
+                    raise ChallengeRequired()
+            raise AuthenticationError(response.status_code)
+        data = response.json()
+        if not isinstance(data, dict):
+            raise ProtocolError("Expected login object")
+        if data.get("requires_2fa"):
+            if not self._otp_callback:
+                raise ChallengeRequired(data.get("method"))
+            challenge = LoginChallenge(data["challenge_id"], data.get("method", "unknown"))
+            code = await self._otp_callback(challenge)
+            if not isinstance(code, str) or not code.strip():
+                raise ValueError("OTP callback must return a nonempty code")
+            async with httpx.AsyncClient(
+                timeout=30,
+                follow_redirects=False,
+                trust_env=False,
+                proxy=self._proxy,
+                transport=DNSHTTPTransport(
+                    self._dns, nameservers=self._dns_servers, port=self._dns_port
+                )
+                if self._dns or self._dns_servers
+                else None,
+            ) as http:
+                verification = await http.post(
+                    f"https://{host}/api/auth/login/2fa",
+                    json={"challenge_id": challenge.challenge_id, "code": code.strip()},
+                )
+            if not verification.is_success:
+                raise AuthenticationError(verification.status_code)
+            data = verification.json()
+        if not data.get("access_token"):
+            raise ProtocolError("Login response lacks an access token")
+        return Session(data["access_token"], host)
+
+
+class BrowserAuth:
+    """Optional Playwright provider; visible browser permits manual challenges.
+
+    Bynix web app uses localStorage['token']. The result is subsequently validated
+    by the client's /auth/me request, never assumed authenticated from the page URL.
+    """
+
+    def __init__(self, email=None, password=None, *, headless=False, timeout=180, profile_dir=None):
+        self._email, self._password = email, password
+        self.headless, self.timeout = headless, timeout
+        self.profile_dir = Path(profile_dir).expanduser().resolve() if profile_dir else None
+
+    async def __call__(self, host):
+        from playwright.async_api import async_playwright
+
+        async with async_playwright() as p:
+            browser = None
+            context = None
+            try:
+                if self.profile_dir:
+                    context = await p.chromium.launch_persistent_context(
+                        str(self.profile_dir), headless=self.headless
+                    )
+                    page = await context.new_page()
+                else:
+                    browser = await p.chromium.launch(headless=self.headless)
+                    context = await browser.new_context()
+                    page = await context.new_page()
+                await page.goto(f"https://{host}/login", wait_until="domcontentloaded")
+                existing = await page.evaluate("localStorage.getItem('token')")
+                if existing:
+                    profile = await page.request.get(
+                        f"https://{host}/api/auth/me",
+                        headers={"Authorization": f"Bearer {existing}"},
+                    )
+                    if profile.status == 401:
+                        await page.evaluate(
+                            "localStorage.removeItem('token'); localStorage.removeItem('user')"
+                        )
+                        existing = None
+                        await page.goto(f"https://{host}/login", wait_until="domcontentloaded")
+                    elif profile.status != 200:
+                        raise AuthenticationError(profile.status)
+                if not existing and self._email and self._password:
+                    await page.get_by_test_id("login-email").fill(self._email)
+                    await page.get_by_test_id("login-password").fill(self._password)
+                    await page.get_by_test_id("login-submit").click()
+                await page.wait_for_function(
+                    "Boolean(localStorage.getItem('token'))", timeout=self.timeout * 1000
+                )
+                token = await page.evaluate("localStorage.getItem('token')")
+                return Session(token, host)
+            finally:
+                if context:
+                    await context.close()
+                if browser:
+                    await browser.close()
+
+
+class AuthChain:
+    """Fall back only on an interactive challenge, not bad credentials/rate limits."""
+
+    def __init__(self, *providers: SessionProvider):
+        if not providers:
+            raise ValueError("At least one provider is required")
+        self.providers = providers
+
+    async def __call__(self, host):
+        for provider in self.providers:
+            try:
+                return await provider(host)
+            except ChallengeRequired:
+                continue
+        raise ChallengeRequired()
+
+
+def load_session(path: str | Path) -> Session:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    return Session(data["token"], data["host"])
+
+
+def save_session(session: Session, path: str | Path):
+    """Opt-in plaintext export; protect the containing directory on Windows."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", dir=path.parent, prefix=".pybynix-session-", delete=False
+        ) as stream:
+            temporary = Path(stream.name)
+            os.chmod(temporary, 0o600)
+            json.dump({"host": session.host, "token": session.token}, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+    finally:
+        if temporary is not None and temporary.exists():
+            temporary.unlink()

pybynix/cli.py

@@ -0,0 +1,158 @@
+"""Login, market data and diagnostics."""
+
+import argparse
+import asyncio
+import getpass
+import json
+import os
+from pathlib import Path
+
+from . import (
+    BrowserAuth,
+    Bynix,
+    PasswordAuth,
+    Session,
+    __version__,
+    export_candles,
+    load_session,
+    save_session,
+)
+from .domains import check_domains
+from .errors import BynixError
+
+
+async def run(args):
+    host = args.host or os.getenv("BYNIX_HOST", "bynixbrokers.com")
+    if args.command == "domains":
+        print(json.dumps(await check_domains(), indent=2))
+        return
+    if args.command == "login":
+        if args.browser:
+            provider = BrowserAuth(profile_dir=args.profile_dir)
+        else:
+            email = os.getenv("BYNIX_EMAIL") or input("Bynix email: ").strip()
+            password = os.getenv("BYNIX_PASSWORD") or getpass.getpass("Bynix password: ")
+
+            async def otp(challenge):
+                return getpass.getpass(f"{challenge.method} verification code: ").strip()
+
+            provider = PasswordAuth(email, password, otp_callback=otp)
+        async with Bynix(host=host, provider=provider, timeout=args.timeout) as client:
+            save_session(client.session, args.session)
+            print(f"Session saved to {args.session}. Keep this file private.")
+        return
+    token = os.getenv("BYNIX_TOKEN")
+    session = Session(token, host) if token else None
+    if session is None and args.session.is_file():
+        session = load_session(args.session)
+        if args.host is None:
+            host = session.host
+    provider = None
+    if os.getenv("BYNIX_EMAIL") and os.getenv("BYNIX_PASSWORD"):
+        provider = PasswordAuth(os.environ["BYNIX_EMAIL"], os.environ["BYNIX_PASSWORD"])
+    anonymous = session is None and provider is None
+    if anonymous and args.command in {"balances", "trades"}:
+        raise ValueError("Run pybynix login first or supply BYNIX_TOKEN")
+    async with Bynix(
+        session=session,
+        provider=provider,
+        anonymous=anonymous,
+        host=host,
+        stream_transport=args.transport,
+        timeout=args.timeout,
+    ) as client:
+        if args.command == "doctor":
+            value = {
+                "version": __version__,
+                "connected": client.connected,
+                "mode": "public" if anonymous else "authenticated",
+                "websocket": client._socket.connected,
+                "platform": await client.get_platform_status(),
+                "assets": len(await client.get_assets()),
+                "clock": await client.get_server_clock(),
+            }
+        elif args.command == "assets":
+            value = await client.get_assets()
+        elif args.command == "payouts":
+            value = await client.get_payouts()
+        elif args.command == "balances":
+            value = await client.get_balance_breakdown()
+        elif args.command == "trades":
+            value = await client.get_trade_history(account_type=args.account, limit=args.count)
+        elif args.command == "candles":
+            candles = await client.get_candles(
+                args.symbol, count=args.count, interval=args.interval
+            )
+            if args.output:
+                export_candles(candles, args.output)
+                print(f"Saved {len(candles)} candles to {args.output}")
+                return
+            value = [
+                {
+                    "timestamp": c.timestamp,
+                    "open": c.open,
+                    "high": c.high,
+                    "low": c.low,
+                    "close": c.close,
+                    "volume": c.volume,
+                }
+                for c in candles
+            ]
+        elif args.command == "sentiment":
+            value = await client.get_realtime_sentiment(args.symbol)
+        elif args.command == "stream":
+            async with await client.subscribe_ticks(args.symbol, interval=args.interval) as ticks:
+                for _ in range(args.count):
+                    tick = await asyncio.wait_for(anext(ticks), args.timeout)
+                    print(
+                        json.dumps(
+                            {
+                                "symbol": tick.symbol,
+                                "timestamp": tick.timestamp,
+                                "price": str(tick.price),
+                                "payout": str(tick.payout),
+                            }
+                        )
+                    )
+            return
+        print(json.dumps(value, indent=2, default=str))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="PyBynix login, market data and diagnostics")
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument(
+        "command",
+        choices=[
+            "login",
+            "doctor",
+            "domains",
+            "assets",
+            "payouts",
+            "balances",
+            "trades",
+            "candles",
+            "stream",
+            "sentiment",
+        ],
+    )
+    parser.add_argument("--host")
+    parser.add_argument("--session", type=Path, default=Path.home() / ".pybynix" / "session.json")
+    parser.add_argument("--browser", action="store_true", help="Interactive browser login")
+    parser.add_argument("--profile-dir", type=Path)
+    parser.add_argument("--transport", choices=["auto", "websocket", "polling"], default="auto")
+    parser.add_argument("--symbol", default="EUR/USD OTC")
+    parser.add_argument("--interval", default="1m")
+    parser.add_argument("--count", type=int, default=5)
+    parser.add_argument("--timeout", type=float, default=20)
+    parser.add_argument("--account", choices=["demo", "real", "funded"], default="demo")
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    if args.count < 1:
+        parser.error("count must be positive")
+    try:
+        asyncio.run(run(args))
+    except (BynixError, ValueError, RuntimeError, OSError, TimeoutError) as error:
+        parser.exit(1, f"{type(error).__name__}: {error}\n")
+    except KeyboardInterrupt:
+        parser.exit(130)