tigeropen 3.5.9__py3-none-any.whl

build/lib/tigeropen/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2018/9/16
+
+@author: gaoan
+"""
+__VERSION__ = '3.5.9'

build/lib/tigeropen/cli/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+TigerOpen CLI package.
+"""
+from tigeropen.cli.main import main
+
+__all__ = ['main']

build/lib/tigeropen/cli/account_cmd.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""
+Account commands: info, assets, analytics.
+"""
+import click
+
+from tigeropen.cli.client_factory import get_trade_client
+from tigeropen.cli.formatting import render, to_records, is_empty
+
+
+@click.group('account')
+def account():
+    """Account information and assets."""
+    pass
+
+
+@account.command('info')
+@click.pass_context
+def account_info(ctx):
+    """Show account information."""
+    client = get_trade_client(ctx.obj)
+    accounts = client.get_managed_accounts()
+    if not is_empty(accounts):
+        data = to_records(accounts)
+        render(data, ctx.obj['format'])
+    else:
+        click.echo('No account info available.')
+
+
+def _segment_to_dict(segment):
+    """Serialize a Segment object to a plain dict."""
+    d = {k: v for k, v in segment.__dict__.items() if not k.startswith('_')}
+    d['currency_assets'] = {
+        currency: {k: v for k, v in ca.__dict__.items() if not k.startswith('_')}
+        for currency, ca in segment.currency_assets.items()
+    }
+    return d
+
+
+def _portfolio_account_to_dict(account):
+    """Serialize a PortfolioAccount object to a plain dict."""
+    return {
+        'account': account.account,
+        'update_timestamp': account.update_timestamp,
+        'segments': {
+            key: _segment_to_dict(seg)
+            for key, seg in account._segments.items()
+        },
+    }
+
+
+@account.command('assets')
+@click.option('--currency', default=None, help='Currency filter (USD, HKD, etc.).')
+@click.pass_context
+def account_assets(ctx, currency):
+    """Show account asset summary."""
+    client = get_trade_client(ctx.obj)
+    kwargs = {}
+    if currency:
+        kwargs['base_currency'] = currency
+    result = client.get_prime_assets(**kwargs)
+    if not is_empty(result):
+        render(_portfolio_account_to_dict(result), ctx.obj['format'])
+    else:
+        click.echo('No asset data available.')
+
+
+@account.command('analytics')
+@click.option('--start-date', default=None, help='Start date (YYYY-MM-DD).')
+@click.option('--end-date', default=None, help='End date (YYYY-MM-DD).')
+@click.pass_context
+def account_analytics(ctx, start_date, end_date):
+    """Show asset analytics."""
+    client = get_trade_client(ctx.obj)
+    kwargs = {}
+    if start_date:
+        kwargs['start_date'] = start_date
+    if end_date:
+        kwargs['end_date'] = end_date
+    result = client.get_analytics_asset(**kwargs)
+    if not is_empty(result):
+        render(result, ctx.obj['format'])
+    else:
+        click.echo('No analytics data available.')

build/lib/tigeropen/cli/client_factory.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""
+Client factory module for CLI.
+Handles config resolution, private key loading, and lazy client creation.
+"""
+import os
+from pathlib import Path
+
+from tigeropen import __VERSION__
+from tigeropen.common.util.signature_utils import read_private_key
+from tigeropen.tiger_open_config import TigerOpenClientConfig
+
+DEFAULT_CONFIG_DIR = str(Path.home() / '.tigeropen')
+
+
+def resolve_private_key(key_input):
+    """
+    Resolve private key from file path, PEM string, or raw key string.
+
+    :param key_input: file path, PEM string with headers, or raw key string
+    :return: stripped private key string (no PEM headers)
+    """
+    if not key_input:
+        return ''
+
+    # If it's an existing file path, read from file
+    if os.path.isfile(key_input):
+        return read_private_key(key_input)
+
+    # If it's a full PEM string with headers, strip them
+    if '-----BEGIN RSA PRIVATE KEY-----' in key_input:
+        return key_input.replace('-----BEGIN RSA PRIVATE KEY-----', '') \
+            .replace('-----END RSA PRIVATE KEY-----', '') \
+            .replace('\n', '').strip()
+
+    # Otherwise treat as raw key string
+    return key_input
+
+
+def build_config(ctx_obj):
+    """
+    Build TigerOpenClientConfig from CLI context dict.
+
+    :param ctx_obj: dict with optional keys: config_path, tiger_id, account, private_key, language
+    :return: TigerOpenClientConfig
+    """
+    config_path = ctx_obj.get('config_path') or DEFAULT_CONFIG_DIR
+    config = TigerOpenClientConfig(enable_dynamic_domain=False,
+                                   props_path=config_path)
+    config._channel = f"tigercli"
+
+    if ctx_obj.get('tiger_id'):
+        config.tiger_id = ctx_obj['tiger_id']
+    if ctx_obj.get('account'):
+        config.account = ctx_obj['account']
+    if ctx_obj.get('private_key'):
+        config.private_key = resolve_private_key(ctx_obj['private_key'])
+    if ctx_obj.get('language'):
+        config.language = ctx_obj['language']
+
+    return config
+
+
+def get_quote_client(ctx_obj):
+    """Lazily create and cache a QuoteClient."""
+    if '_quote_client' not in ctx_obj:
+        from tigeropen.quote.quote_client import QuoteClient
+        config = build_config(ctx_obj)
+        ctx_obj['_quote_client'] = QuoteClient(config, is_grab_permission=False)
+    return ctx_obj['_quote_client']
+
+
+def get_trade_client(ctx_obj):
+    """Lazily create and cache a TradeClient."""
+    if '_trade_client' not in ctx_obj:
+        from tigeropen.trade.trade_client import TradeClient
+        config = build_config(ctx_obj)
+        ctx_obj['_trade_client'] = TradeClient(config)
+    return ctx_obj['_trade_client']

build/lib/tigeropen/cli/config_cmd.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""
+Config commands: init, show, set, path.
+"""
+import os
+
+import click
+from jproperties import Properties
+
+from tigeropen.tiger_open_config import DEFAULT_PROPS_FILE
+from tigeropen.cli.client_factory import resolve_private_key, DEFAULT_CONFIG_DIR
+
+
+@click.group('config')
+def config():
+    """Manage tigeropen configuration."""
+    pass
+
+
+@config.command('init')
+@click.pass_context
+def config_init(ctx):
+    """Interactive configuration setup."""
+    tiger_id = click.prompt('Tiger ID')
+    account = click.prompt('Account')
+
+    # Private key: support multi-line paste (PEM or raw base64).
+    # Read lines until an empty line signals end of input.
+    click.echo('Private Key (file path or key content, blank line to finish):')
+    lines = []
+    stdin = click.get_text_stream('stdin')
+    while True:
+        line = stdin.readline()
+        if not line:  # EOF
+            break
+        line = line.rstrip('\n').rstrip('\r')
+        if not line and lines:
+            break
+        if line:
+            lines.append(line)
+    private_key = ''.join(lines)
+
+    if not private_key:
+        raise click.ClickException('Private key cannot be empty.')
+
+    secret_key = click.prompt('Secret Key (institutional only, press Enter to skip)',
+                              default='', show_default=False)
+    config_dir = click.prompt('Config directory', default=DEFAULT_CONFIG_DIR)
+
+    os.makedirs(config_dir, exist_ok=True)
+    props_file = os.path.join(config_dir, DEFAULT_PROPS_FILE)
+
+    p = Properties()
+    p['tiger_id'] = tiger_id
+    p['account'] = account
+    p['private_key_pk8'] = resolve_private_key(private_key)
+
+    if secret_key:
+        p['secret_key'] = secret_key
+
+    with open(props_file, 'wb') as f:
+        p.store(f, encoding='utf-8')
+
+    click.echo(f'Config written to {props_file}')
+
+
+@config.command('show')
+@click.pass_context
+def config_show(ctx):
+    """Display current configuration (private key masked)."""
+    config_path = ctx.obj.get('config_path') if ctx.obj else None
+    config_path = config_path or DEFAULT_CONFIG_DIR
+    if os.path.isdir(config_path):
+        props_file = os.path.join(config_path, DEFAULT_PROPS_FILE)
+    else:
+        props_file = config_path
+
+    if not os.path.exists(props_file):
+        click.echo(f'Config file not found: {props_file}')
+        return
+
+    p = Properties()
+    with open(props_file, 'rb') as f:
+        p.load(f, 'utf-8')
+
+    for key in p:
+        value = p[key].data
+        if 'private_key' in key and value:
+            # Mask: show first 4 and last 4 chars
+            if len(value) > 8:
+                value = value[:4] + '****' + value[-4:]
+            else:
+                value = '****'
+        click.echo(f'{key}={value}')
+
+
+@config.command('set')
+@click.argument('key')
+@click.argument('value')
+@click.pass_context
+def config_set(ctx, key, value):
+    """Set a configuration value."""
+    config_path = ctx.obj.get('config_path') if ctx.obj else None
+    config_path = config_path or DEFAULT_CONFIG_DIR
+    if os.path.isdir(config_path):
+        props_file = os.path.join(config_path, DEFAULT_PROPS_FILE)
+    else:
+        props_file = config_path
+
+    p = Properties()
+    if os.path.exists(props_file):
+        with open(props_file, 'rb') as f:
+            p.load(f, 'utf-8')
+
+    p[key] = value
+
+    os.makedirs(os.path.dirname(props_file) if os.path.dirname(props_file) else '.', exist_ok=True)
+    with open(props_file, 'wb') as f:
+        p.store(f, encoding='utf-8')
+
+    click.echo(f'Set {key}={value}')
+
+
+@config.command('path')
+@click.pass_context
+def config_path(ctx):
+    """Print the config directory path."""
+    config_dir = ctx.obj.get('config_path') if ctx.obj else None
+    click.echo(config_dir or DEFAULT_CONFIG_DIR)

build/lib/tigeropen/cli/formatting.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+Output formatting module for CLI.
+Supports table, json, csv formats.
+"""
+import csv
+import io
+import json
+import sys
+
+import pandas as pd
+
+
+def is_empty(data):
+    """Check if data is empty (None, empty DataFrame, empty list, etc.)."""
+    if data is None:
+        return True
+    if isinstance(data, pd.DataFrame):
+        return data.empty
+    if isinstance(data, (list, dict)):
+        return len(data) == 0
+    return False
+
+
+def to_records(items):
+    """Convert a list of domain objects to a list of dicts for rendering.
+    If items is already a DataFrame, return it as-is.
+    Handles objects with __dict__, __slots__ + to_dict(), or plain dicts."""
+    if isinstance(items, pd.DataFrame):
+        return items
+    records = []
+    for item in items:
+        if hasattr(item, 'to_dict'):
+            d = item.to_dict()
+        elif hasattr(item, '__dict__'):
+            d = item.__dict__
+        else:
+            records.append(item)
+            continue
+        # Flatten nested objects to str for display
+        flat = {}
+        for k, v in d.items():
+            if v is not None and hasattr(v, '__dict__') and not isinstance(v, (str, int, float, bool)):
+                flat[k] = str(v)
+            elif isinstance(v, list) and v and hasattr(v[0], '__dict__'):
+                flat[k] = str(v)
+            else:
+                flat[k] = v
+        records.append(flat)
+    return records
+
+
+def render(data, fmt='table', file=None):
+    """
+    Render data in the specified format.
+
+    :param data: DataFrame, dict, list of dicts, string, or None
+    :param fmt: 'table', 'json', or 'csv'
+    :param file: output file object, defaults to sys.stdout
+    """
+    if file is None:
+        file = sys.stdout
+
+    if data is None:
+        return
+
+    if isinstance(data, str):
+        file.write(data + '\n')
+        return
+
+    if fmt == 'json':
+        _render_json(data, file)
+    elif fmt == 'csv':
+        _render_csv(data, file)
+    else:
+        _render_table(data, file)
+
+
+def _render_table(data, file):
+    if isinstance(data, pd.DataFrame):
+        if data.empty:
+            return
+        file.write(data.to_string(index=False) + '\n')
+    elif isinstance(data, list) and data and isinstance(data[0], dict):
+        df = pd.DataFrame(data)
+        file.write(df.to_string(index=False) + '\n')
+    elif isinstance(data, dict):
+        for k, v in data.items():
+            file.write(f'{k}: {v}\n')
+    else:
+        file.write(str(data) + '\n')
+
+
+def _render_json(data, file):
+    if isinstance(data, pd.DataFrame):
+        records = data.to_dict(orient='records')
+        file.write(json.dumps(records, ensure_ascii=False, indent=2) + '\n')
+    elif isinstance(data, (dict, list)):
+        file.write(json.dumps(data, ensure_ascii=False, indent=2, default=str) + '\n')
+    else:
+        file.write(json.dumps(str(data), ensure_ascii=False) + '\n')
+
+
+def _render_csv(data, file):
+    if isinstance(data, pd.DataFrame):
+        if data.empty:
+            return
+        file.write(data.to_csv(index=False))
+    elif isinstance(data, list) and data and isinstance(data[0], dict):
+        writer = csv.DictWriter(file, fieldnames=data[0].keys())
+        writer.writeheader()
+        writer.writerows(data)
+    elif isinstance(data, dict):
+        writer = csv.writer(file)
+        writer.writerow(['key', 'value'])
+        for k, v in data.items():
+            writer.writerow([k, v])

build/lib/tigeropen/cli/main.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+"""
+Main CLI entry point for tigeropen.
+"""
+import sys
+import traceback
+
+import click
+
+from tigeropen import __VERSION__
+from tigeropen.common.exceptions import ApiException
+from tigeropen.cli.config_cmd import config
+from tigeropen.cli.quote_cmd import quote
+from tigeropen.cli.trade_cmd import trade
+from tigeropen.cli.account_cmd import account
+
+CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
+
+GETTING_STARTED = """\
+TigerOpen CLI v{version} — Tiger Brokers Open API
+
+Getting started:
+
+  1. Run interactive setup:
+     $ tigeropen config init
+
+  2. Or set environment variables:
+     $ export TIGEROPEN_TIGER_ID="your_tiger_id"
+     $ export TIGEROPEN_PRIVATE_KEY="your_private_key"
+     $ export TIGEROPEN_ACCOUNT="your_account"
+
+  3. Query market data:
+     $ tigeropen quote briefs AAPL TSLA
+     $ tigeropen quote bars AAPL --period day --limit 10
+
+  4. Manage orders:
+     $ tigeropen trade order list
+     $ tigeropen trade position list
+
+  5. View account:
+     $ tigeropen account assets
+
+Run 'tigeropen -h' to see all commands and options.
+Run 'tigeropen <command> -h' for help on a specific command.
+"""
+
+
+class TigerCLI(click.Group):
+    """Custom click Group that catches API/generic exceptions and shows
+    a getting-started guide when invoked with no arguments."""
+
+    def invoke(self, ctx):
+        try:
+            return super().invoke(ctx)
+        except click.exceptions.Exit:
+            raise
+        except click.exceptions.Abort:
+            click.echo('Aborted.', err=True)
+            sys.exit(1)
+        except ApiException as e:
+            click.echo(f'API Error [{e.code}]: {e.msg}')
+            if ctx.obj and ctx.obj.get('verbose'):
+                traceback.print_exc()
+            sys.exit(1)
+        except Exception as e:
+            click.echo(f'Error: {e}')
+            if ctx.obj and ctx.obj.get('verbose'):
+                traceback.print_exc()
+            sys.exit(1)
+
+    # Global options that can appear anywhere in the command line
+    _GLOBAL_OPTIONS = {
+        '-f': 1, '--format': 1,
+        '-c': 1, '--config-path': 1,
+        '-l': 1, '--language': 1,
+        '-v': 0, '--verbose': 0,
+    }
+
+    def parse_args(self, ctx, args):
+        if not args:
+            click.echo(GETTING_STARTED.format(version=__VERSION__))
+            ctx.exit(0)
+        # Move global options to the front so Click's group parser can see them.
+        # This allows e.g. `tigeropen quote briefs AAPL -f json` to work.
+        front = []
+        rest = []
+        i = 0
+        args = list(args)
+        while i < len(args):
+            arg = args[i]
+            if arg in self._GLOBAL_OPTIONS:
+                n_values = self._GLOBAL_OPTIONS[arg]
+                front.append(arg)
+                for j in range(n_values):
+                    if i + 1 + j < len(args):
+                        front.append(args[i + 1 + j])
+                i += 1 + n_values
+            else:
+                rest.append(arg)
+                i += 1
+        return super().parse_args(ctx, front + rest)
+
+
+@click.group(cls=TigerCLI, context_settings=CONTEXT_SETTINGS)
+@click.option('--config-path', '-c', type=click.Path(), envvar='TIGEROPEN_PROPS_PATH',
+              help='Path to config directory or properties file.')
+@click.option('--format', '-f', 'output_format',
+              type=click.Choice(['table', 'json', 'csv'], case_sensitive=False),
+              default='json', help='Output format.')
+@click.option('--language', '-l',
+              type=click.Choice(['en_US', 'zh_CN', 'zh_TW'], case_sensitive=False),
+              default='en_US', help='Language.')
+@click.option('--verbose', '-v', is_flag=True, help='Enable debug logging.')
+@click.pass_context
+def cli(ctx, config_path, output_format, language, verbose):
+    """TigerOpen CLI - Tiger Brokers Open API command line tool."""
+    ctx.ensure_object(dict)
+    ctx.obj['config_path'] = config_path
+    ctx.obj['format'] = output_format
+    ctx.obj['language'] = language
+    ctx.obj['verbose'] = verbose
+
+
+@cli.command('version')
+def version():
+    """Print the SDK version."""
+    click.echo(__VERSION__)
+
+
+@cli.command('uninstall')
+@click.option('--remove-config', is_flag=True, help='Also remove ~/.tigeropen/ configuration directory.')
+@click.option('-y', '--yes', is_flag=True, help='Skip confirmation prompts.')
+def uninstall(remove_config, yes):
+    """Uninstall tigeropen and optionally remove configuration."""
+    import subprocess
+    import shutil
+    from pathlib import Path
+
+    if not yes:
+        msg = 'Uninstall tigeropen?'
+        if remove_config:
+            msg += ' (including ~/.tigeropen/ config directory)'
+        if not click.confirm(msg):
+            raise SystemExit(0)
+
+    # Remove config directory first (before pip uninstall removes the CLI itself)
+    if remove_config:
+        config_dir = Path.home() / '.tigeropen'
+        if config_dir.exists():
+            shutil.rmtree(config_dir)
+            click.echo(f'Removed {config_dir}')
+        else:
+            click.echo(f'{config_dir} not found, skipping.')
+
+    # Run pip uninstall with the same Python interpreter
+    click.echo('Uninstalling tigeropen...')
+    result = subprocess.run(
+        [sys.executable, '-m', 'pip', 'uninstall', 'tigeropen', '-y'],
+        capture_output=True, text=True,
+    )
+    if result.returncode == 0:
+        click.echo('tigeropen has been uninstalled.')
+    else:
+        click.echo(f'pip uninstall failed:\n{result.stderr.strip()}', err=True)
+        sys.exit(1)
+
+
+cli.add_command(config)
+cli.add_command(quote)
+cli.add_command(trade)
+cli.add_command(account)
+
+
+def _load_push_command():
+    """Lazy-load push command to avoid importing protobuf at startup."""
+    try:
+        from tigeropen.cli.push_cmd import push
+        cli.add_command(push)
+    except ImportError:
+        @cli.command('push')
+        @click.argument('args', nargs=-1)
+        def push_unavailable(args):
+            """Real-time data streaming (requires protobuf>=5.28)."""
+            click.echo('Error: push command requires protobuf>=5.28.\n'
+                        'Please upgrade:  pip install --upgrade protobuf')
+            sys.exit(1)
+
+
+_load_push_command()
+
+
+def main():
+    cli()
+
+
+if __name__ == '__main__':
+    main()