#!/usr/bin/env python3
"""查询同花顺板块列表（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.request
import os

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def main():
    parser = argparse.ArgumentParser(description="查询同花顺板块列表")
    parser.add_argument("--module", choices=["concept", "csrc", "industry", "region"],
                        help="板块类型过滤：concept/csrc/industry/region")
    parser.add_argument("--search", default=None, help="搜索板块名称或代码")
    args = parser.parse_args()

    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    url = f"{BASE_URL}/api/v1/market/data/ths-board-list"
    req = urllib.request.Request(url, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key}, method="GET")

    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()[:500] if e.fp else ""
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Connection error: {e.reason}", file=sys.stderr)
        sys.exit(1)

    if not isinstance(data, dict) or not isinstance(data.get("data"), list):
        print("Unexpected response format", file=sys.stderr)
        sys.exit(1)

    rows = data["data"]
    if args.module:
        rows = [b for b in rows if b.get("module") == args.module]

    if args.search:
        q = args.search.lower()
        rows = [b for b in rows if q in b.get("name", "").lower() or q in b.get("code", "")]

    data["data"] = rows
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/abnormal-trading-details'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='龙虎榜明细')
    parser.add_argument("--date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    args = parser.parse_args()
    params = {}
    if args.date is not None: params["date"] = args.date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/abnormal-trading-overview'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='龙虎榜总览')
    parser.add_argument("--date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--symbol_name")
    parser.add_argument("--change_rate", required=False)
    parser.add_argument("--close", required=False)
    parser.add_argument("--turnover", required=False)
    args = parser.parse_args()
    params = {}
    if args.date is not None: params["date"] = args.date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.symbol_name is not None: params["symbol_name"] = args.symbol_name
    if args.change_rate is not None: params["change_rate"] = args.change_rate
    if args.close is not None: params["close"] = args.close
    if args.turnover is not None: params["turnover"] = args.turnover
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL=os.environ.get("FTSHARE_BASE_URL","https://market.ft.tech/gateway").rstrip("/"); ENDPOINT="/api/v1/market/data/stk-code-change"
_REQUEST_HEADERS={"Content-Type":"application/json"}
def safe_urlopen(request):
 url=request.full_url if isinstance(request,urllib.request.Request) else str(request)
 parsed=urllib.parse.urlparse(url); base=urllib.parse.urlparse(BASE_URL)
 if (parsed.scheme,parsed.netloc)!=(base.scheme,base.netloc): print("Invalid URL for safe_urlopen",file=sys.stderr); raise SystemExit(1)
 if not isinstance(request,urllib.request.Request): request=urllib.request.Request(url,headers=_REQUEST_HEADERS,method="GET")
 return urllib.request.urlopen(request,timeout=30)
def fetch(params):
 key=os.environ.get("FTSHARE_API_KEY")
 if not key: print("FTSHARE_API_KEY environment variable is required",file=sys.stderr); raise SystemExit(2)
 url=BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params); b,p=urllib.parse.urlparse(BASE_URL),urllib.parse.urlparse(url)
 if (b.scheme,b.netloc)!=(p.scheme,p.netloc): print("Invalid URL for safe_urlopen",file=sys.stderr); raise SystemExit(1)
 try:
  with safe_urlopen(urllib.request.Request(url,headers={"FTSHARE_API_KEY":key,"Content-Type":"application/json"},method="GET")) as r:return json.loads(r.read().decode())
 except urllib.error.HTTPError as e: print(f"HTTP {e.code}: {e.read().decode()}",file=sys.stderr); raise SystemExit(1)
 except urllib.error.URLError as e: print(f"请求失败: {e.reason}",file=sys.stderr); raise SystemExit(1)
def main():
 p=argparse.ArgumentParser(description="查询 A 股代码变更"); p.add_argument("--trade-code",required=True); p.add_argument("--start-date"); p.add_argument("--end-date"); a=p.parse_args()
 if not a.trade_code.strip(): p.error("trade-code 不能为空")
 if a.start_date and a.end_date and a.start_date>a.end_date: p.error("start-date 不得晚于 end-date")
 params={"trade_code":a.trade_code};
 if a.start_date: params["start_date"]=a.start_date
 if a.end_date: params["end_date"]=a.end_date
 print(json.dumps(fetch(params),ensure_ascii=False,indent=2))
if __name__=="__main__":main()

import importlib.util
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch

_DIR = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_DIR, "handler.py"))
handler = importlib.util.module_from_spec(spec)
spec.loader.exec_module(handler)

class TestHandler(unittest.TestCase):
    @patch.object(handler, "fetch")
    def test_required_code_and_dates(self, mock_fetch):
        mock_fetch.return_value = {"code": 200, "data": []}
        with patch.object(sys, "argv", ["handler.py", "--trade-code", "001872.SZ,920000.BJ", "--start-date", "20180101", "--end-date", "20241231"]), patch("sys.stdout", new_callable=StringIO) as out:
            handler.main()
        self.assertEqual(mock_fetch.call_args.args[0], {"trade_code": "001872.SZ,920000.BJ", "start_date": "20180101", "end_date": "20241231"})
        self.assertEqual(json.loads(out.getvalue())["code"], 200)

if __name__ == "__main__": unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/ashare-interactions'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='e互动')
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--trade_code")
    parser.add_argument("--company_name")
    parser.add_argument("--industry_code")
    parser.add_argument("--industry_name")
    parser.add_argument("--data_source")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    args = parser.parse_args()
    params = {}
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.trade_code is not None: params["trade_code"] = args.trade_code
    if args.company_name is not None: params["company_name"] = args.company_name
    if args.industry_code is not None: params["industry_code"] = args.industry_code
    if args.industry_name is not None: params["industry_name"] = args.industry_name
    if args.data_source is not None: params["data_source"] = args.data_source
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v3/market/data/ashare-news-sentiment-factors'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='查询 A 股新闻情绪因子')
    parser.add_argument("--trade-code", required=True)
    parser.add_argument("--start-date")
    parser.add_argument("--end-date")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", type=int, default=50)

    args = parser.parse_args()
    params = {}
    if args.trade_code is not None:
        params['trade_code'] = args.trade_code
    if args.start_date is not None:
        params['start_date'] = args.start_date
    if args.end_date is not None:
        params['end_date'] = args.end_date
    if args.page is not None:
        params['page'] = args.page
    if args.page_size is not None:
        params['page_size'] = args.page_size

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v3/market/data/ashare-rating-factor-snapshot"
_REQUEST_HEADERS = {"X-Client-Name": "ft-claw", "Content-Type": "application/json"}
if os.environ.get("FTSHARE_API_KEY"):
    _REQUEST_HEADERS["FTSHARE_API_KEY"] = os.environ["FTSHARE_API_KEY"]
OPENER = urllib.request.build_opener()


def safe_urlopen(request):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    return OPENER.open(request, timeout=60)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser()
    parser.add_argument("--trade-code", required=True)
    parser.add_argument("--date")
    parser.add_argument("--top-k", type=int)
    args = parser.parse_args()
    params = {"trade_code": args.trade_code}
    if args.date is not None:
        params["date"] = args.date
    if args.top_k is not None:
        params["top_k"] = args.top_k
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    try:
        with safe_urlopen(request) as response:
            result = json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL=os.environ.get("FTSHARE_BASE_URL","https://market.ft.tech/gateway").rstrip("/"); ENDPOINT="/api/v1/market/data/stk-status-change"
_REQUEST_HEADERS={"Content-Type":"application/json"}
def safe_urlopen(request):
 url=request.full_url if isinstance(request,urllib.request.Request) else str(request)
 parsed=urllib.parse.urlparse(url); base=urllib.parse.urlparse(BASE_URL)
 if (parsed.scheme,parsed.netloc)!=(base.scheme,base.netloc): print("Invalid URL for safe_urlopen",file=sys.stderr); raise SystemExit(1)
 if not isinstance(request,urllib.request.Request): request=urllib.request.Request(url,headers=_REQUEST_HEADERS,method="GET")
 return urllib.request.urlopen(request,timeout=30)
def fetch(params):
 key=os.environ.get("FTSHARE_API_KEY")
 if not key: print("FTSHARE_API_KEY environment variable is required",file=sys.stderr); raise SystemExit(2)
 url=BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params); b,p=urllib.parse.urlparse(BASE_URL),urllib.parse.urlparse(url)
 if (b.scheme,b.netloc)!=(p.scheme,p.netloc): print("Invalid URL for safe_urlopen",file=sys.stderr); raise SystemExit(1)
 try:
  with safe_urlopen(urllib.request.Request(url,headers={"FTSHARE_API_KEY":key,"Content-Type":"application/json"},method="GET")) as r:return json.loads(r.read().decode())
 except urllib.error.HTTPError as e: print(f"HTTP {e.code}: {e.read().decode()}",file=sys.stderr); raise SystemExit(1)
 except urllib.error.URLError as e: print(f"请求失败: {e.reason}",file=sys.stderr); raise SystemExit(1)
def main():
 p=argparse.ArgumentParser(description="查询 A 股状态变更"); p.add_argument("--trade-code"); p.add_argument("--change-date"); p.add_argument("--change-type"); a=p.parse_args()
 params={k:v for k,v in (("trade_code",a.trade_code),("change_date",a.change_date),("change_type",a.change_type)) if v is not None}
 print(json.dumps(fetch(params),ensure_ascii=False,indent=2))
if __name__=="__main__":main()

import importlib.util
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch

_DIR = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_DIR, "handler.py"))
handler = importlib.util.module_from_spec(spec)
spec.loader.exec_module(handler)

class TestHandler(unittest.TestCase):
    @patch.object(handler, "fetch")
    def test_optional_filters(self, mock_fetch):
        mock_fetch.return_value = {"code": 200, "data": []}
        with patch.object(sys, "argv", ["handler.py", "--trade-code", "600848.SH", "--change-date", "20240101", "--change-type", "上市"]), patch("sys.stdout", new_callable=StringIO) as out:
            handler.main()
        self.assertEqual(mock_fetch.call_args.args[0], {"trade_code": "600848.SH", "change_date": "20240101", "change_type": "上市"})
        self.assertEqual(json.loads(out.getvalue())["code"], 200)

if __name__ == "__main__": unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/auction-results'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='集合竞价结果')
    parser.add_argument("--ts_code")
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--close", required=False)
    parser.add_argument("--open", required=False)
    parser.add_argument("--high", required=False)
    parser.add_argument("--low", required=False)
    parser.add_argument("--volume", required=False)
    parser.add_argument("--amount", required=False)
    parser.add_argument("--vwap", required=False)
    args = parser.parse_args()
    params = {}
    if args.ts_code is not None: params["ts_code"] = args.ts_code
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.close is not None: params["close"] = args.close
    if args.open is not None: params["open"] = args.open
    if args.high is not None: params["high"] = args.high
    if args.low is not None: params["low"] = args.low
    if args.volume is not None: params["volume"] = args.volume
    if args.amount is not None: params["amount"] = args.amount
    if args.vwap is not None: params["vwap"] = args.vwap
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询 A 股大宗交易列表"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/block-trades"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/bse-mapping'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='查询北交所代码映射')
    parser.add_argument("--o-code", dest="o_code")

    args = parser.parse_args()
    params = {}
    if args.o_code is not None:
        params['o_code'] = args.o_code

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/bullion/price'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='贵金属价格')
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--page", required=True)
    parser.add_argument("--page_size", required=True)
    parser.add_argument("--total", required=False)
    parser.add_argument("--date", required=True)
    parser.add_argument("--value", required=False)
    args = parser.parse_args()
    params = {}
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.date is not None: params["date"] = args.date
    if args.value is not None: params["value"] = args.value
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/finance/cashflow-stock-code'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='现金流支持股票代码')
    parser.add_argument("--items", required=False)
    parser.add_argument("--stock_code", required=True)
    parser.add_argument("--stock_name", required=True)
    args = parser.parse_args()
    params = {}
    if args.items is not None: params["items"] = args.items
    if args.stock_code is not None: params["stock_code"] = args.stock_code
    if args.stock_name is not None: params["stock_name"] = args.stock_name
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""获取可转债全量列表（market.ft.tech）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)



def main():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    url = BASE_URL + "/api/v1/market/data/cb/cb-lists"
    req = urllib.request.Request(url, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key}, method="GET")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/chinabond-yield-daily'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='中债收益率曲线日度')
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--curve_name")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--trade_date", required=True)
    args = parser.parse_args()
    params = {}
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.curve_name is not None: params["curve_name"] = args.curve_name
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.curve_name is not None: params["curve_name"] = args.curve_name
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/company-list'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='查询公司列表')
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)

    args = parser.parse_args()
    params = {}
    if args.page is not None:
        params['page'] = args.page
    if args.page_size is not None:
        params['page_size'] = args.page_size

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/intraday-auction-volume"
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ.get("FTSHARE_API_KEY", ""), "Content-Type": "application/json"}


def fetch(params):
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if (parsed.scheme, parsed.netloc) != (base.scheme, base.netloc):
        print("Invalid URL for safe_urlopen", file=sys.stderr)
        raise SystemExit(1)
    request = urllib.request.Request(url, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key}, method="GET")
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


def main():
    parser = argparse.ArgumentParser(description="查询连续竞价成交量")
    parser.add_argument("--trade-date", dest="trade_date")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)
    parser.add_argument("--all", action="store_true", dest="fetch_all")
    args = parser.parse_args()
    if args.page < 1 or not 1 <= args.page_size <= 200:
        parser.error("page 须大于等于 1，page-size 须在 1～200 之间")
    params = {"page": 1 if args.fetch_all else args.page, "page_size": args.page_size}
    if args.trade_date is not None:
        params["trade_date"] = args.trade_date
    result = fetch(params)
    if args.fetch_all:
        data = result.get("data") or {}
        records = list(data.get("records", []))
        for page in range(2, int(data.get("pages", 1)) + 1):
            records.extend((fetch({**params, "page": page}).get("data") or {}).get("records", []))
        result["data"] = {**data, "records": records}
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询单只可转债历史日/周/月/年 K 线（GET /api/v1/market/data/convertible-bond-candlesticks）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/convertible-bond-candlesticks"

INTERVAL_UNITS = ("Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def build_body(symbol, interval_unit, interval_value, adjust_kind,
               since_ts_millis, until_ts_millis, limit):
    body = {
        "symbol": symbol,
        "interval_unit": interval_unit,
        "since_ts_millis": since_ts_millis,
        "until_ts_millis": until_ts_millis,
    }
    if interval_value is not None:
        body["interval_value"] = interval_value
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(
symbol, interval_unit, interval_value, adjust_kind,
          since_ts_millis, until_ts_millis, limit):
    body = build_body(symbol, interval_unit, interval_value, adjust_kind,
                      since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    url = f"{BASE_URL}{ENDPOINT}?{query}"
    req = urllib.request.Request(
        url,
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        msg = e.read().decode()
        print(f"HTTP {e.code}: {msg}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只可转债历史日/周/月/年 K 线（GET 查询参数，不支持分钟周期）")
    parser.add_argument("--symbol", required=True, help="可转债代码，如 113042.SH、123107.SZ")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True, type=str.capitalize,
                        choices=INTERVAL_UNITS, help="K 线周期：Day/Week/Month/Year（大小写不敏感，不支持 Minute）")
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=None,
                        help="间隔数值，周期查询无需设置")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int,
                        help="开始时间戳（毫秒）；与结束时间跨度不得超过 12 个自然月")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None,
                        help="返回条数上限；省略时返回窗口内全部记录")
    args = parser.parse_args()

    if args.since_ts_millis > args.until_ts_millis:
        print("--since-ts-millis 不能晚于 --until-ts-millis", file=sys.stderr)
        raise SystemExit(2)

    data = fetch(args.symbol, args.interval_unit, args.interval_value,
                 args.adjust_kind, args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for convertible-bond-candlesticks handler"""
import json
import sys
import unittest
import urllib.error
from io import BytesIO, StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

SINCE = 1786291200000
UNTIL = 1786377599999


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_get_to_cb_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("113042.SH", "Day", None, "None", SINCE, UNTIL, 1)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v1/market/data/convertible-bond-candlesticks", req.full_url)
        self.assertIsNone(req.data)
        self.assertIn("symbol=113042.SH", req.full_url)
        self.assertIn(f"since_ts_millis={SINCE}", req.full_url)
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")

    @patch.object(handler, "safe_urlopen")
    def test_http_error_exits(self, mock_open):
        mock_open.side_effect = urllib.error.HTTPError(
            "https://fake", 500, "Internal Error", {}, BytesIO(b"server error")
        )
        with self.assertRaises(SystemExit):
            handler.fetch("113042.SH", "Day", None, "None", SINCE, UNTIL, None)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", [
                "handler.py", "--symbol", "113042.SH", "--interval-unit", "Day",
                "--since-ts-millis", str(SINCE), "--until-ts-millis", str(UNTIL)
            ]):
                with patch("sys.stdout", new_callable=StringIO) as fake_out:
                    handler.main()
                    self.assertEqual(json.loads(fake_out.getvalue()), [])

    def test_main_requires_since(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", [
                "handler.py", "--symbol", "113042.SH", "--interval-unit", "Day",
                "--until-ts-millis", str(UNTIL)
            ]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_minute_interval(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", [
                "handler.py", "--symbol", "113042.SH", "--interval-unit", "Minute",
                "--since-ts-millis", str(SINCE), "--until-ts-millis", str(UNTIL)
            ]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_since_after_until(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", [
                "handler.py", "--symbol", "113042.SH", "--interval-unit", "Day",
                "--since-ts-millis", str(UNTIL), "--until-ts-millis", str(SINCE)
            ]):
                with self.assertRaises(SystemExit):
                    handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""批量查询多只可转债历史日/周/月/年 K 线（GET /api/v2/market/data/convertible-bond-candlesticks/batch）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/convertible-bond-candlesticks/batch"

INTERVAL_UNITS = ("Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")
MAX_SYMBOLS = 20

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def parse_symbols(raw):
    syms = [s.strip() for s in raw.split(",") if s.strip()]
    if not syms:
        print("--symbols 不能为空", file=sys.stderr)
        sys.exit(1)
    if len(syms) > MAX_SYMBOLS:
        print(f"--symbols 最多 {MAX_SYMBOLS} 个标的，当前 {len(syms)} 个", file=sys.stderr)
        sys.exit(1)
    return syms


def build_query(symbols, interval_unit, interval_value, adjust_kind,
                since_ts_millis, until_ts_millis, limit):
    body = {
        "symbols": symbols,
        "interval_unit": interval_unit,
        "since_ts_millis": since_ts_millis,
        "until_ts_millis": until_ts_millis,
    }
    if interval_value is not None:
        body["interval_value"] = interval_value
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(symbols, interval_unit, interval_value, adjust_kind,
          since_ts_millis, until_ts_millis, limit):
    body = build_query(symbols, interval_unit, interval_value, adjust_kind,
                       since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="批量获取多只可转债的历史日/周/月/年 K 线（不支持分钟周期）")
    parser.add_argument("--symbols", required=True,
                        help="可转债代码列表，逗号分隔，1～20 只，如 113042.SH,123107.SZ；也接受 .XSHG/.XSHE 长后缀")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True, type=str.capitalize,
                        choices=INTERVAL_UNITS, help="K 线周期：Day/Week/Month/Year（大小写不敏感，不支持 Minute）")
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=None,
                        help="间隔数值，周期查询无需设置")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int,
                        help="开始时间戳（毫秒）；与结束时间跨度不得超过 12 个自然月")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None,
                        help="每个标的返回条数上限；省略时返回窗口内全部记录")
    args = parser.parse_args()

    if args.since_ts_millis > args.until_ts_millis:
        print("--since-ts-millis 不能晚于 --until-ts-millis", file=sys.stderr)
        raise SystemExit(2)

    symbols = parse_symbols(args.symbols)
    data = fetch(symbols, args.interval_unit, args.interval_value, args.adjust_kind,
                 args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for convertible-bond-candlesticks-batch handler"""
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

SINCE = "1786291200000"
UNTIL = "1786377599999"


class TestBuildQuery(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_required_only(self):
        body = handler.build_query(["113042.SH"], "Day", None, "None", 1786291200000, 1786377599999, None)
        self.assertEqual(body["symbols"], ["113042.SH"])
        self.assertEqual(body["interval_unit"], "Day")
        self.assertEqual(body["since_ts_millis"], 1786291200000)
        self.assertEqual(body["until_ts_millis"], 1786377599999)
        self.assertNotIn("adjust_kind", body)
        self.assertNotIn("limit", body)
        self.assertNotIn("interval_value", body)

    def test_optional_fields(self):
        body = handler.build_query(["113042.SH", "123107.SZ"], "Week", 1, "Forward",
                                   1786291200000, 1786377599999, 2)
        self.assertEqual(body["symbols"], ["113042.SH", "123107.SZ"])
        self.assertEqual(body["adjust_kind"], "Forward")
        self.assertEqual(body["interval_value"], 1)
        self.assertEqual(body["limit"], 2)

    def test_rejects_too_many_symbols(self):
        with self.assertRaises(SystemExit):
            handler.parse_symbols(",".join(f"11304{i}.SH" for i in range(21)))


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_query_string_expands_symbols(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch(["113042.SH", "123107.SZ"], "Day", None, "None", 1786291200000, 1786377599999, 1)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v2/market/data/convertible-bond-candlesticks/batch", req.full_url)
        query = req.full_url.split("?", 1)[1]
        self.assertIn("symbols=113042.SH", query)
        self.assertIn("symbols=123107.SZ", query)
        self.assertIn("interval_unit=Day", query)
        self.assertIn("since_ts_millis=1786291200000", query)
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'{"code":200,"message":"success","data":[["113042.SH",'
            b'[{"open":"117.1980","close":"116.8380","ts_millis":1786345200000}]]]}'
        )
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "113042.SH,123107.SZ",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL, "--limit", "1"]):
                with patch("sys.stdout", new_callable=StringIO) as out:
                    handler.main()
                    data = json.loads(out.getvalue())
                    self.assertEqual(data["data"][0][0], "113042.SH")

    def test_main_rejects_minute_interval(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "113042.SH",
                                            "--interval-unit", "Minute",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_requires_since(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "113042.SH",
                                            "--interval-unit", "Day",
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_since_after_until(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "113042.SH",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", UNTIL,
                                            "--until-ts-millis", SINCE]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_requires_symbols(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--interval-unit", "Day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询单只或批量可转债历史分钟 K 线（GET /api/v2/market/data/convertible-bond-minute-candlesticks）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/convertible-bond-minute-candlesticks"

INTERVAL_VALUES = (1, 5, 15)
MAX_SYMBOLS = 20

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def parse_symbols(raw):
    syms = [s.strip() for s in raw.split(",") if s.strip()]
    if not syms:
        print("--symbols 不能为空", file=sys.stderr)
        sys.exit(1)
    if len(syms) > MAX_SYMBOLS:
        print(f"--symbols 最多 {MAX_SYMBOLS} 个标的，当前 {len(syms)} 个", file=sys.stderr)
        sys.exit(1)
    return syms


def build_query(symbol, symbols, interval_value, since_ts_millis, until_ts_millis, limit):
    body = {}
    if symbol is not None:
        body["symbol"] = symbol
    if symbols is not None:
        body["symbols"] = symbols
    if interval_value is not None:
        body["interval_value"] = interval_value
    body["since_ts_millis"] = since_ts_millis
    body["until_ts_millis"] = until_ts_millis
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(symbol, symbols, interval_value, since_ts_millis, until_ts_millis, limit):
    body = build_query(symbol, symbols, interval_value, since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只或批量可转债历史分钟 K 线（GET 查询参数）")
    target = parser.add_mutually_exclusive_group(required=True)
    target.add_argument("--symbol", help="单只可转债代码，如 113042.SH")
    target.add_argument("--symbols", help="可转债代码列表，逗号分隔，1～20 只，如 113042.SH,123107.SZ")
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=None,
                        choices=INTERVAL_VALUES, help="分钟周期：1/5/15，默认 1")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int,
                        help="起始时间戳（毫秒）；与结束时间相差不超过 3 个北京时间自然日")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None,
                        help="每只标的聚合后返回条数上限，范围 1～1000；省略返回窗口内全部记录")
    args = parser.parse_args()

    if args.since_ts_millis > args.until_ts_millis:
        print("--since-ts-millis 不能晚于 --until-ts-millis", file=sys.stderr)
        raise SystemExit(2)
    if args.limit is not None and not 1 <= args.limit <= 1000:
        print("--limit 须在 1～1000 之间", file=sys.stderr)
        raise SystemExit(2)

    symbols = parse_symbols(args.symbols) if args.symbols is not None else None
    data = fetch(args.symbol, symbols, args.interval_value,
                 args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for convertible-bond-minutes handler"""
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

SINCE = "1786291200000"
UNTIL = "1786377599999"


class TestBuildQuery(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_single_symbol_query(self):
        body = handler.build_query("113042.SH", None, None, 1786291200000, 1786377599999, 1)
        self.assertEqual(body["symbol"], "113042.SH")
        self.assertNotIn("symbols", body)
        self.assertNotIn("interval_value", body)
        self.assertEqual(body["limit"], 1)

    def test_batch_symbols_query(self):
        body = handler.build_query(None, ["113042.SH", "123107.SZ"], 5,
                                   1786291200000, 1786377599999, None)
        self.assertNotIn("symbol", body)
        self.assertEqual(body["symbols"], ["113042.SH", "123107.SZ"])
        self.assertEqual(body["interval_value"], 5)
        self.assertNotIn("limit", body)

    def test_rejects_too_many_symbols(self):
        with self.assertRaises(SystemExit):
            handler.parse_symbols(",".join(f"11304{i}.SH" for i in range(21)))


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_query_string_expands_symbols(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch(None, ["113042.SH", "123107.SZ"], 1, 1786291200000, 1786377599999, 1)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v2/market/data/convertible-bond-minute-candlesticks", req.full_url)
        query = req.full_url.split("?", 1)[1]
        self.assertIn("symbols=113042.SH", query)
        self.assertIn("symbols=123107.SZ", query)
        self.assertIn("interval_value=1", query)
        self.assertIn("since_ts_millis=1786291200000", query)
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")

    @patch.object(handler, "safe_urlopen")
    def test_single_symbol_uses_symbol_key(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("113042.SH", None, None, 1786291200000, 1786377599999, None)
        query = mock_open.call_args[0][0].full_url.split("?", 1)[1]
        self.assertIn("symbol=113042.SH", query)
        self.assertNotIn("symbols=", query)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_single_symbol(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbol", "113042.SH",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with patch("sys.stdout", new_callable=StringIO) as out:
                    handler.main()
                    self.assertEqual(json.loads(out.getvalue()), [])

    def test_main_requires_target(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_symbol_and_symbols_together(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py",
                                            "--symbol", "113042.SH",
                                            "--symbols", "123107.SZ",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_bad_interval_value(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbol", "113042.SH",
                                            "--interval-value", "7",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_limit_out_of_range(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbol", "113042.SH",
                                            "--limit", "1001",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询单只或批量可转债当前交易日实时日 K 线（GET /api/v4/market/data/convertible-bond-realtime-day-kline）"""
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v4/market/data/convertible-bond-realtime-day-kline"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
MAX_SYMBOLS = 20


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        request.add_unredirected_header(key, value)
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只或批量可转债实时日 K 线")
    parser.add_argument("--symbols", nargs="+", required=True,
                        help="可转债代码，空格分隔，1～20 只，如 113042.SH 123107.SZ")
    args = parser.parse_args()

    symbols = args.symbols
    if len(symbols) > MAX_SYMBOLS:
        print(f"--symbols 最多 {MAX_SYMBOLS} 个标的，当前 {len(symbols)} 个", file=sys.stderr)
        raise SystemExit(2)

    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode({"symbols": json.dumps(symbols, ensure_ascii=False)})
    request = urllib.request.Request(url, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询单只或批量可转债当前交易日实时 1 分钟 K 线（GET /api/v4/market/data/convertible-bond-realtime-minute-kline）"""
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v4/market/data/convertible-bond-realtime-minute-kline"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
MAX_SYMBOLS = 20


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        request.add_unredirected_header(key, value)
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只或批量可转债实时分钟 K 线")
    parser.add_argument("--symbols", nargs="+", required=True,
                        help="可转债代码，空格分隔，1～20 只，如 113042.SH 123107.SZ")
    args = parser.parse_args()

    symbols = args.symbols
    if len(symbols) > MAX_SYMBOLS:
        print(f"--symbols 最多 {MAX_SYMBOLS} 个标的，当前 {len(symbols)} 个", file=sys.stderr)
        raise SystemExit(2)

    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode({"symbols": json.dumps(symbols, ensure_ascii=False)})
    request = urllib.request.Request(url, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/convertible-bond/szse/declaration-snapshots'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='深交所可转债申报快照')
    parser.add_argument("--security-code", dest="security_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/convertible-bond/szse/directed-trades'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='深交所可转债定向成交')
    parser.add_argument("--security-code", dest="security_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/convertible-bond/szse/matching-trades'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='深交所可转债匹配成交')
    parser.add_argument("--security-code", dest="security_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/convertible-bond/szse/negotiated-trades'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='深交所可转债协议成交')
    parser.add_argument("--security-code", dest="security_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v4/market/data/daec/history/prices'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='标的分时数据')
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--range")
    parser.add_argument("--days")
    parser.add_argument("--ts_ms")
    parser.add_argument("--price", required=False)
    parser.add_argument("--avg_price")
    parser.add_argument("--volume", required=False)
    parser.add_argument("--turnover", required=False)
    args = parser.parse_args()
    params = {}
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.range is not None: params["range"] = args.range
    if args.days is not None: params["days"] = args.days
    if args.ts_ms is not None: params["ts_ms"] = args.ts_ms
    if args.ts_ms is not None: params["ts_ms"] = args.ts_ms
    if args.price is not None: params["price"] = args.price
    if args.avg_price is not None: params["avg_price"] = args.avg_price
    if args.volume is not None: params["volume"] = args.volume
    if args.turnover is not None: params["turnover"] = args.turnover
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/daec/market/snapshot'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='市场行情快照')
    parser.add_argument("--scope")
    parser.add_argument("--status", required=False)
    parser.add_argument("--change_rate", required=False)
    parser.add_argument("--volume", required=False)
    parser.add_argument("--turnover", required=False)
    parser.add_argument("--prev_turnover")
    parser.add_argument("--distribution", required=False)
    args = parser.parse_args()
    params = {}
    if args.scope is not None: params["scope"] = args.scope
    if args.status is not None: params["status"] = args.status
    if args.change_rate is not None: params["change_rate"] = args.change_rate
    if args.volume is not None: params["volume"] = args.volume
    if args.turnover is not None: params["turnover"] = args.turnover
    if args.prev_turnover is not None: params["prev_turnover"] = args.prev_turnover
    if args.distribution is not None: params["distribution"] = args.distribution
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/daec/history/prev-closes'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='标的昨收价')
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--since", required=True)
    parser.add_argument("--until", required=True)
    args = parser.parse_args()
    params = {}
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.since is not None: params["since"] = args.since
    if args.until is not None: params["until"] = args.until
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""分页查询东方财富全部板块历史日线 OHLC，按板块代码、日期排序"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/eastmoney-all-board-daily-ohlc"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def fetch_page(page: int, page_size: int, **extra) -> dict:
    params = {"page": page, "page_size": page_size}
    params.update({k: v for k, v in extra.items() if v is not None})
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="查询东方财富全板块日线 OHLC")
    parser.add_argument("--start_date", default=None, help="起始日期（含），YYYY-MM-DD 或 YYYYMMDD")
    parser.add_argument("--end_date", default=None, help="截止日期（含），YYYY-MM-DD 或 YYYYMMDD")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始，默认 1；传 0 时按 1 处理")
    parser.add_argument("--page_size", type=int, default=50, help="每页数量，默认 50；传 0 时按 1 处理，最大 200")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    extra = dict(start_date=args.start_date, end_date=args.end_date)

    if args.fetch_all:
        first = fetch_page(1, args.page_size, **extra)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        pages = data.get("pages", 1)
        for p in range(2, pages + 1):
            d = fetch_page(p, args.page_size, **extra).get("data") or {}
            records.extend(d.get("records", []))
        result = {
            "code": first.get("code"), "message": first.get("message"),
            "data": {"pageNum": 1, "pageSize": args.page_size,
                     "total": data.get("total", len(records)), "pages": pages, "records": records},
        }
    else:
        result = fetch_page(args.page, args.page_size, **extra)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询东财板块成分股"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/eastmoney-board-constituents"


def fetch(
board_code: str) -> dict:
    params = urllib.parse.urlencode({"board_code": board_code})
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询东财板块成分股")
    parser.add_argument("--board_code", required=True, help="板块代码（BK 前缀），如 BK1024")
    args = parser.parse_args()

    result = fetch(args.board_code)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询东财单板块历史 OHLC 数据，支持日期范围过滤与分页"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/eastmoney-board-daily-ohlc"


def fetch_page(board_code: str, page: int, page_size: int, start_date: str = None, end_date: str = None) -> dict:
    params = {"board_code": board_code, "page": page, "page_size": page_size}
    if start_date:
        params["start_date"] = start_date
    if end_date:
        params["end_date"] = end_date
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询东财单板块历史 OHLC 数据")
    parser.add_argument("--board_code", required=True, help="板块代码，如 BK1024")
    parser.add_argument("--start_date", default=None, help="起始日期（含），格式 YYYY-MM-DD 或 YYYYMMDD")
    parser.add_argument("--end_date", default=None, help="截止日期（含），格式 YYYY-MM-DD 或 YYYYMMDD")
    parser.add_argument("--page", type=int, default=1, help="页码（从 1 开始）")
    parser.add_argument("--page_size", type=int, default=50, help="每页记录数")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    if args.fetch_all:
        first = fetch_page(args.board_code, 1, args.page_size, args.start_date, args.end_date)
        all_items = list(first.get("items", []))
        total_pages = first.get("total_pages", 1)
        for p in range(2, total_pages + 1):
            page_data = fetch_page(args.board_code, p, args.page_size, args.start_date, args.end_date)
            all_items.extend(page_data.get("items", []))
        result = {
            "items": all_items,
            "total_pages": total_pages,
            "total_items": first.get("total_items", len(all_items)),
        }
    else:
        result = fetch_page(args.board_code, args.page, args.page_size, args.start_date, args.end_date)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询东财概念板块列表，返回全量板块基础信息"""
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/eastmoney-concept-boards"


def fetch():
    url = f"{BASE_URL}{ENDPOINT}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    result = fetch()
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/eastmoney-dapan-flow'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='东方财富大盘资金流')
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--sh_close", required=False)
    parser.add_argument("--sh_change_pct", required=False)
    parser.add_argument("--sz_close", required=False)
    parser.add_argument("--sz_change_pct", required=False)
    parser.add_argument("--main_net", required=False)
    parser.add_argument("--main_pct", required=False)
    parser.add_argument("--xlarge_net", required=False)
    parser.add_argument("--xlarge_pct", required=False)
    parser.add_argument("--large_net", required=False)
    parser.add_argument("--large_pct", required=False)
    parser.add_argument("--mid_net", required=False)
    parser.add_argument("--mid_pct", required=False)
    parser.add_argument("--small_net", required=False)
    parser.add_argument("--small_pct", required=False)
    parser.add_argument("--name", required=True)
    args = parser.parse_args()
    params = {}
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.sh_close is not None: params["sh_close"] = args.sh_close
    if args.sh_change_pct is not None: params["sh_change_pct"] = args.sh_change_pct
    if args.sz_close is not None: params["sz_close"] = args.sz_close
    if args.sz_change_pct is not None: params["sz_change_pct"] = args.sz_change_pct
    if args.main_net is not None: params["main_net"] = args.main_net
    if args.main_pct is not None: params["main_pct"] = args.main_pct
    if args.xlarge_net is not None: params["xlarge_net"] = args.xlarge_net
    if args.xlarge_pct is not None: params["xlarge_pct"] = args.xlarge_pct
    if args.large_net is not None: params["large_net"] = args.large_net
    if args.large_pct is not None: params["large_pct"] = args.large_pct
    if args.mid_net is not None: params["mid_net"] = args.mid_net
    if args.mid_pct is not None: params["mid_pct"] = args.mid_pct
    if args.small_net is not None: params["small_net"] = args.small_net
    if args.small_pct is not None: params["small_pct"] = args.small_pct
    if args.name is not None: params["name"] = args.name
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/eastmoney-futures-position'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='东方财富期货持仓')
    parser.add_argument("--exchange", dest="exchange")
    parser.add_argument("--variety-code", dest="variety_code")
    parser.add_argument("--contract-code", dest="contract_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--start-date", dest="start_date", type=int)
    parser.add_argument("--end-date", dest="end_date", type=int)
    parser.add_argument("--member-name-abbr", dest="member_name_abbr")
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询东方财富期货龙虎榜面板（成交量/持仓量多空排名等），按交易所/品种/合约/交易日"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/eastmoney-futures-strange"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def main():
    parser = argparse.ArgumentParser(description="查询东方财富期货龙虎榜面板")
    parser.add_argument("--exchange", required=True, help="交易所代码：shfe/dce/czce/cffex/ine/gfe")
    parser.add_argument("--variety", required=True, help="品种名称，如 多晶硅")
    parser.add_argument("--contract", required=True, help="合约代码，如 ps2609")
    parser.add_argument("--trade_date", required=True, help="交易日 YYYYMMDD")
    args = parser.parse_args()

    params = {
        "exchange": args.exchange,
        "variety": args.variety,
        "contract": args.contract,
        "trade_date": args.trade_date,
    }
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询东财市场日估值数据（主要市场指数 PE/市值/点位），支持单市场、单日、区间查询与分页"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/eastmoney-market-valuation"


def fetch(
market_code: str = None, trade_date: str = None, start_date: str = None,
          end_date: str = None, page: int = 1, page_size: int = 50) -> dict:
    params = {"page": page, "page_size": page_size}
    if market_code:
        params["market_code"] = market_code
    if trade_date:
        params["trade_date"] = trade_date
    if start_date:
        params["start_date"] = start_date
    if end_date:
        params["end_date"] = end_date
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询东财市场日估值数据")
    parser.add_argument("--market_code", default=None, help="市场代码，如 000001=上证指数, 000300=沪深300, 399001=深证成指, 399006=创业板指, 000688=科创50, 899050=北证50")
    parser.add_argument("--trade_date", default=None, help="交易日，格式 YYYY-MM-DD")
    parser.add_argument("--start_date", default=None, help="区间起始日，格式 YYYY-MM-DD")
    parser.add_argument("--end_date", default=None, help="区间结束日，格式 YYYY-MM-DD")
    parser.add_argument("--page", type=int, default=1, help="页码（从 1 开始，默认 1）")
    parser.add_argument("--page_size", type=int, default=50, help="每页条数（默认 50，最大 500）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    if args.fetch_all:
        first = fetch(args.market_code, args.trade_date, args.start_date, args.end_date, 1, args.page_size)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        total_pages = data.get("pages", 1)
        for p in range(2, total_pages + 1):
            page_data = fetch(args.market_code, args.trade_date, args.start_date, args.end_date, p, args.page_size)
            pdata = page_data.get("data") or {}
            records.extend(pdata.get("records", []))
        result = {
            "code": first.get("code", 0),
            "message": first.get("message", "success"),
            "data": {
                "pageNum": 1,
                "pageSize": args.page_size,
                "total": len(records),
                "pages": 1,
                "records": records,
            },
        }
    else:
        result = fetch(args.market_code, args.trade_date, args.start_date, args.end_date, args.page, args.page_size)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/eastmoney-rank'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='东方财富股票排名')
    parser.add_argument("--rank_group")
    parser.add_argument("--market")
    parser.add_argument("--trade_date")
    parser.add_argument("--display_name", required=True)
    parser.add_argument("--metric_name", required=True)
    parser.add_argument("--total", required=False)
    parser.add_argument("--items", required=False)
    parser.add_argument("--rank_no", required=True)
    parser.add_argument("--rank_change", required=False)
    parser.add_argument("--normalized_symbol", required=False)
    parser.add_argument("--stock_name", required=True)
    parser.add_argument("--hot_score", required=False)
    parser.add_argument("--latest_price", required=False)
    parser.add_argument("--change_amount", required=False)
    parser.add_argument("--change_pct", required=False)
    parser.add_argument("--raw_symbol", required=False)
    args = parser.parse_args()
    params = {}
    if args.rank_group is not None: params["rank_group"] = args.rank_group
    if args.market is not None: params["market"] = args.market
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.display_name is not None: params["display_name"] = args.display_name
    if args.metric_name is not None: params["metric_name"] = args.metric_name
    if args.total is not None: params["total"] = args.total
    if args.items is not None: params["items"] = args.items
    if args.rank_no is not None: params["rank_no"] = args.rank_no
    if args.rank_change is not None: params["rank_change"] = args.rank_change
    if args.normalized_symbol is not None: params["normalized_symbol"] = args.normalized_symbol
    if args.stock_name is not None: params["stock_name"] = args.stock_name
    if args.hot_score is not None: params["hot_score"] = args.hot_score
    if args.latest_price is not None: params["latest_price"] = args.latest_price
    if args.change_amount is not None: params["change_amount"] = args.change_amount
    if args.change_pct is not None: params["change_pct"] = args.change_pct
    if args.raw_symbol is not None: params["raw_symbol"] = args.raw_symbol
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""东方财富板块资金流（GET /api/v1/market/data/eastmoney-sector-flow）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/eastmoney-sector-flow"

BOARD_TYPES = ("industry", "concept", "regional")

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_params(args):
    params = {}
    if args.board_code is not None:
        params["board_code"] = args.board_code
    if args.board_type is not None:
        params["board_type"] = args.board_type
    if args.board_level is not None:
        params["board_level"] = args.board_level
    if args.trade_date is not None:
        params["trade_date"] = args.trade_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params


def fetch(params):
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="东方财富板块（行业/概念/地域）日资金流")
    parser.add_argument("--board-code", dest="board_code", default=None,
                        help="板块代码，如 BK0488")
    parser.add_argument("--board-type", dest="board_type", default=None, choices=BOARD_TYPES,
                        help="板块类型：industry（行业）/concept（概念）/regional（地域）")
    parser.add_argument("--board-level", dest="board_level", type=int, default=None,
                        help="行业层级：1=一级、2=二级、3=三级；不传返回全部层级，仅匹配 industry")
    parser.add_argument("--trade-date", dest="trade_date", default=None, help="交易日 YYYYMMDD")
    parser.add_argument("--start-date", dest="start_date", default=None, help="区间起始日 YYYYMMDD")
    parser.add_argument("--end-date", dest="end_date", default=None, help="区间结束日 YYYYMMDD")
    parser.add_argument("--page", type=int, default=None, help="页码，从 1 开始，默认 1")
    parser.add_argument("--page-size", dest="page_size", type=int, default=None,
                        help="每页条数，默认 50，最大 500")
    args = parser.parse_args()

    print(json.dumps(fetch(build_params(args)), ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for eastmoney-sector-flow handler (board_* parameter rename)"""
import os
import sys
import unittest
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


def _run(argv):
    with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
        with patch.object(sys, "argv", ["handler.py"] + argv):
            handler.main()


class TestBoardParams(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_board_params_sent(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--board-code", "BK0488", "--board-type", "industry",
              "--board-level", "2", "--page", "1", "--page-size", "5"])
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/eastmoney-sector-flow", req.full_url)
        self.assertIn("board_code=BK0488", req.full_url)
        self.assertIn("board_type=industry", req.full_url)
        self.assertIn("board_level=2", req.full_url)
        self.assertNotIn("sector_code", req.full_url)
        self.assertNotIn("sector_type", req.full_url)
        self.assertNotIn("sector_level", req.full_url)

    def test_rejects_unknown_board_type(self):
        with self.assertRaises(SystemExit):
            _run(["--board-type", "unknown"])

    @patch.object(handler, "safe_urlopen")
    def test_all_params_optional(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run([])
        req = mock_open.call_args[0][0]
        self.assertTrue(req.full_url.endswith("/api/v1/market/data/eastmoney-sector-flow"))


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/holder/stock-ggcg-em"
_REQUEST_HEADERS = {"Content-Type": "application/json"}
def safe_urlopen(request):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    b, p = urllib.parse.urlparse(BASE_URL), urllib.parse.urlparse(url)
    if (b.scheme, b.netloc) != (p.scheme, p.netloc): print("Invalid URL for safe_urlopen", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    return urllib.request.urlopen(request, timeout=30)

def fetch(params):
    key = os.environ.get("FTSHARE_API_KEY")
    if not key: print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    b, p = urllib.parse.urlparse(BASE_URL), urllib.parse.urlparse(url)
    if (b.scheme, b.netloc) != (p.scheme, p.netloc): print("Invalid URL for safe_urlopen", file=sys.stderr); raise SystemExit(1)
    req = urllib.request.Request(url, headers={"FTSHARE_API_KEY": key, "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(req) as r: return json.loads(r.read().decode())
    except urllib.error.HTTPError as e: print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as e: print(f"请求失败: {e.reason}", file=sys.stderr); raise SystemExit(1)
def main():
    p=argparse.ArgumentParser(description="查询东方财富股东增减持"); p.add_argument("--symbol", default="全部"); p.add_argument("--page", type=int, default=1); p.add_argument("--page-size", dest="page_size", type=int, default=50); p.add_argument("--all", action="store_true", dest="fetch_all"); a=p.parse_args()
    if a.symbol not in ("全部", "股东增持", "股东减持"): p.error("symbol 仅支持 全部、股东增持、股东减持")
    if a.page < 1 or not 1 <= a.page_size <= 200: p.error("page 须大于等于 1，page-size 须在 1～200 之间")
    params={"symbol":a.symbol,"page":1 if a.fetch_all else a.page,"page_size":a.page_size}; result=fetch(params)
    if a.fetch_all:
        data=result.get("data") or {}; records=list(data.get("records", []))
        for page in range(2,int(data.get("pages",1))+1): records.extend((fetch({**params,"page":page}).get("data") or {}).get("records", []))
        result["data"]={**data,"records":records}
    print(json.dumps(result, ensure_ascii=False, indent=2))
if __name__ == "__main__": main()

import importlib.util
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch

_DIR = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_DIR, "handler.py"))
handler = importlib.util.module_from_spec(spec)
spec.loader.exec_module(handler)

class TestHandler(unittest.TestCase):
    @patch.object(handler, "fetch")
    def test_symbol_and_paging(self, mock_fetch):
        mock_fetch.return_value = {"code": 200, "data": {"pages": 1, "records": []}}
        with patch.object(sys, "argv", ["handler.py", "--symbol", "股东减持", "--page", "2", "--page-size", "20"]), patch("sys.stdout", new_callable=StringIO) as out:
            handler.main()
        self.assertEqual(mock_fetch.call_args.args[0], {"symbol": "股东减持", "page": 2, "page_size": 20})
        self.assertEqual(json.loads(out.getvalue())["code"], 200)

if __name__ == "__main__": unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/eastmoney-stock-flow'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='东方财富个股资金流')
    parser.add_argument("--symbol")
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--name", required=True)
    parser.add_argument("--market", required=True)
    parser.add_argument("--close_price", required=False)
    parser.add_argument("--change_pct", required=False)
    parser.add_argument("--main_net", required=False)
    parser.add_argument("--main_pct", required=False)
    parser.add_argument("--super_large_net", required=True)
    parser.add_argument("--super_large_pct", required=True)
    parser.add_argument("--large_net", required=False)
    parser.add_argument("--large_pct", required=False)
    parser.add_argument("--medium_net", required=True)
    parser.add_argument("--medium_pct", required=True)
    parser.add_argument("--small_net", required=False)
    parser.add_argument("--small_pct", required=False)
    args = parser.parse_args()
    params = {}
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.name is not None: params["name"] = args.name
    if args.market is not None: params["market"] = args.market
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.close_price is not None: params["close_price"] = args.close_price
    if args.change_pct is not None: params["change_pct"] = args.change_pct
    if args.main_net is not None: params["main_net"] = args.main_net
    if args.main_pct is not None: params["main_pct"] = args.main_pct
    if args.super_large_net is not None: params["super_large_net"] = args.super_large_net
    if args.super_large_pct is not None: params["super_large_pct"] = args.super_large_pct
    if args.large_net is not None: params["large_net"] = args.large_net
    if args.large_pct is not None: params["large_pct"] = args.large_pct
    if args.medium_net is not None: params["medium_net"] = args.medium_net
    if args.medium_pct is not None: params["medium_pct"] = args.medium_pct
    if args.small_net is not None: params["small_net"] = args.small_net
    if args.small_pct is not None: params["small_pct"] = args.small_pct
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询东财个股日估值数据，支持单票、单日、区间查询与分页"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/eastmoney-stock-valuation"


def fetch(
symbol: str = None, trade_date: str = None, start_date: str = None,
          end_date: str = None, page: int = 1, page_size: int = 50) -> dict:
    params = {"page": page, "page_size": page_size}
    if symbol:
        params["symbol"] = symbol
    if trade_date:
        params["trade_date"] = trade_date
    if start_date:
        params["start_date"] = start_date
    if end_date:
        params["end_date"] = end_date
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询东财个股日估值数据")
    parser.add_argument("--symbol", default=None, help="股票代码，6位数字，如 000001")
    parser.add_argument("--trade_date", default=None, help="交易日，格式 YYYY-MM-DD")
    parser.add_argument("--start_date", default=None, help="区间起始日，格式 YYYY-MM-DD")
    parser.add_argument("--end_date", default=None, help="区间结束日，格式 YYYY-MM-DD")
    parser.add_argument("--page", type=int, default=1, help="页码（从 1 开始，默认 1）")
    parser.add_argument("--page_size", type=int, default=50, help="每页条数（默认 50，最大 500）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    if args.fetch_all:
        first = fetch(args.symbol, args.trade_date, args.start_date, args.end_date, 1, args.page_size)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        total_pages = data.get("pages", 1)
        for p in range(2, total_pages + 1):
            page_data = fetch(args.symbol, args.trade_date, args.start_date, args.end_date, p, args.page_size)
            pdata = page_data.get("data") or {}
            records.extend(pdata.get("records", []))
        result = {
            "code": first.get("code", 0),
            "message": first.get("message", "success"),
            "data": {
                "pageNum": 1,
                "pageSize": args.page_size,
                "total": len(records),
                "pages": 1,
                "records": records,
            },
        }
    else:
        result = fetch(args.symbol, args.trade_date, args.start_date, args.end_date, args.page, args.page_size)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询东财美股历史日K线。

有日期范围时：按 3 天窗口分批请求（避免服务端大范围 500），合并去重后客户端分页。
无日期范围时：全量拉取（不传日期参数）。
"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime, timedelta
import os

SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/eastmoney-us-stock-daily-ohlc"


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


MAX_WINDOW_DAYS = 3  # 每次请求日期跨度不超过 3 天


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def _fetch_page(stock_code: str, start_date: str = None, end_date: str = None,
                page: int = 1, page_size: int = 100) -> dict:
    params = {"stock_code": stock_code, "page": page, "page_size": page_size}
    if start_date:
        params["start_date"] = start_date
    if end_date:
        params["end_date"] = end_date
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    with safe_urlopen(url) as resp:
        return json.loads(resp.read().decode())


def _fetch_window_pages(stock_code: str, start: str, end: str, page_size: int = 100) -> list:
    """请求一个日期窗口内所有页的数据。"""
    first = _fetch_page(stock_code, start, end, 1, page_size)
    data = first.get("data") or {}
    records = list(data.get("records", []))
    total_pages = data.get("pages", 1)
    for p in range(2, total_pages + 1):
        page_data = _fetch_page(stock_code, start, end, p, page_size)
        pdata = page_data.get("data") or {}
        records.extend(pdata.get("records", []))
    return records


def _fetch_full(stock_code: str, page_size: int = 100) -> list:
    """全量拉取（不传日期参数）。"""
    first = _fetch_page(stock_code, page=1, page_size=page_size)
    data = first.get("data") or {}
    records = list(data.get("records", []))
    total_pages = data.get("pages", 1)
    for p in range(2, total_pages + 1):
        page_data = _fetch_page(stock_code, page=p, page_size=page_size)
        pdata = page_data.get("data") or {}
        records.extend(pdata.get("records", []))
    return records


def _normalize_date(d: str) -> str:
    d = d.strip().replace("-", "")
    if len(d) == 8:
        return f"{d[:4]}-{d[4:6]}-{d[6:8]}"
    return d


def _date_range_windows(start: str, end: str, max_days: int = 3) -> list:
    """将日期区间拆分为 max_days 天的小窗口。"""
    fmt = "%Y-%m-%d"
    s = datetime.strptime(start, fmt)
    e = datetime.strptime(end, fmt)
    windows = []
    cur = s
    while cur <= e:
        w_end = min(cur + timedelta(days=max_days - 1), e)
        windows.append((cur.strftime(fmt), w_end.strftime(fmt)))
        cur = w_end + timedelta(days=1)
    return windows


def fetch_by_windows(stock_code: str, start_date: str, end_date: str) -> list:
    """按 3 天窗口分批请求，合并去重。"""
    windows = _date_range_windows(start_date, end_date, MAX_WINDOW_DAYS)
    total_wins = len(windows)
    print(f"info: 日期区间 {start_date}~{end_date} 拆分为 {total_wins} 个 {MAX_WINDOW_DAYS} 天窗口", file=sys.stderr)

    all_records = []
    seen = set()
    for i, (ws, we) in enumerate(windows):
        records = _fetch_window_pages(stock_code, ws, we)
        for r in records:
            d = r.get("date", "")
            if d and d not in seen:
                seen.add(d)
                all_records.append(r)
        if total_wins > 1:
            print(f"info: 窗口 {i + 1}/{total_wins} ({ws}~{we}) 获取 {len(records)} 条", file=sys.stderr)

    # 按日期排序
    all_records.sort(key=lambda r: r.get("date", ""))
    return all_records


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询东财美股历史日K线（3天窗口分批）")
    parser.add_argument("--stock_code", required=True, help="股票代码，如 AAL")
    parser.add_argument("--start_date", default=None, help="起始日期（含），格式 YYYY-MM-DD 或 YYYYMMDD")
    parser.add_argument("--end_date", default=None, help="截止日期（含），格式 YYYY-MM-DD 或 YYYYMMDD")
    parser.add_argument("--page", type=int, default=1, help="页码（从 1 开始，默认 1）")
    parser.add_argument("--page_size", type=int, default=50, help="每页条数（默认 50）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="返回全量数据（不分页）")
    args = parser.parse_args()

    has_date_filter = bool(args.start_date or args.end_date)

    if has_date_filter:
        start = _normalize_date(args.start_date) if args.start_date else ""
        end = _normalize_date(args.end_date) if args.end_date else ""
        # 确保至少有一个边界
        if not start:
            start = "2000-01-01"
        if not end:
            end = "2099-12-31"
        records = fetch_by_windows(args.stock_code, start, end)
    else:
        records = _fetch_full(args.stock_code)

    total = len(records)

    if total == 0:
        result = {"code": 0, "message": "success", "data": None}
    elif args.fetch_all:
        result = {
            "code": 0,
            "message": "success",
            "data": {
                "pageNum": 1,
                "pageSize": total,
                "total": total,
                "pages": 1,
                "records": records,
            },
        }
    else:
        start_idx = (args.page - 1) * args.page_size
        end_idx = start_idx + args.page_size
        result = {
            "code": 0,
            "message": "success",
            "data": {
                "pageNum": args.page,
                "pageSize": args.page_size,
                "total": total,
                "pages": max(1, (total + args.page_size - 1) // args.page_size),
                "records": records[start_idx:end_idx],
            },
        }

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/eastmoney-us-stock-list"

_REQUEST_HEADERS = {"Content-Type": "application/json"}

def safe_urlopen(request):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    base = urllib.parse.urlparse(BASE_URL)
    parsed = urllib.parse.urlparse(url)
    if (parsed.scheme, parsed.netloc) != (base.scheme, base.netloc):
        print("Invalid URL for safe_urlopen", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    return urllib.request.urlopen(request, timeout=30)

def fetch(params):
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    base = urllib.parse.urlparse(BASE_URL)
    parsed = urllib.parse.urlparse(url)
    if (parsed.scheme, parsed.netloc) != (base.scheme, base.netloc):
        print("Invalid URL for safe_urlopen", file=sys.stderr)
        raise SystemExit(1)
    request = urllib.request.Request(url, headers={"FTSHARE_API_KEY": key, "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            return json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)

def main():
    parser = argparse.ArgumentParser(description="查询东方财富美股列表")
    parser.add_argument("--refresh", action="store_true")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int)
    parser.add_argument("--all", action="store_true", dest="fetch_all")
    args = parser.parse_args()
    if args.page < 1 or (args.page_size is not None and args.page_size < 1):
        parser.error("page 和 page-size 必须大于等于 1")
    params = {"page": 1 if args.fetch_all else args.page}
    if args.refresh:
        params["refresh"] = "true"
    if args.page_size is not None:
        params["page_size"] = args.page_size
    result = fetch(params)
    if args.fetch_all:
        data = result.get("data") or {}
        records = list(data.get("records", []))
        for page in range(2, int(data.get("pages", 1)) + 1):
            records.extend((fetch({**params, "page": page}).get("data") or {}).get("records", []))
        result["data"] = {**data, "records": records}
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

import importlib.util
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch

_DIR = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_DIR, "handler.py"))
handler = importlib.util.module_from_spec(spec)
spec.loader.exec_module(handler)

class TestHandler(unittest.TestCase):
    @patch.object(handler, "fetch")
    def test_contract_and_json(self, mock_fetch):
        mock_fetch.return_value = {"code": 200, "data": {"pages": 1, "records": []}}
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}), patch.object(sys, "argv", ["handler.py", "--refresh", "--page", "2", "--page-size", "5"]), patch("sys.stdout", new_callable=StringIO) as out:
            handler.main()
        self.assertEqual(mock_fetch.call_args.args[0], {"page": 2, "refresh": "true", "page_size": 5})
        self.assertEqual(json.loads(out.getvalue())["code"], 200)

if __name__ == "__main__": unittest.main()

#!/usr/bin/env python3
"""中国居民消费价格指数 CPI（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-cpi"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国信贷数据（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-credit-loans"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国海关进出口（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-customs-trade"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国财政收入月度数据"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-fiscal-revenue"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国城镇固定资产投资（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-fixed-asset-investment"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国 GDP 季度数据"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-gdp"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国工业增加值增长（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-industrial-added-value"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国 LPR 贷款市场报价利率（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-lpr"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国货币供应量 M0/M1/M2（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-money-supply"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国 PMI 数据（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-pmi"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国 PPI 工业品出厂价格指数（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-ppi"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国存款准备金率（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-reserve-ratio"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国社会消费品零售总额（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-retail-sales"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""中国全国税收收入（月度）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    url = f"{BASE_URL}/api/v1/market/data/economic/china-tax-revenue"

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""美国经济指标按 type 查询（统一接口）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


VALID_TYPES = [
    "ism-manufacturing",
    "ism-non-manufacturing",
    "nonfarm-payroll",
    "trade-balance",
    "unemployment-rate",
    "ppi-mom",
    "cpi-mom",
    "cpi-yoy",
    "core-cpi-mom",
    "core-cpi-yoy",
    "housing-starts",
    "existing-home-sales",
    "durable-goods-orders-mom",
    "cb-consumer-confidence",
    "gdp-yoy-preliminary",
    "fed-funds-rate-upper",
]


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(
        description="按 type 查询美国经济指标，返回时间序列（前值、现值、发布日期）"
    )
    parser.add_argument(
        "--type",
        required=True,
        choices=VALID_TYPES,
        help="指标类型，如 ism-manufacturing, nonfarm-payroll, cpi-mom 等",
    )
    args = parser.parse_args()

    params = {"type": args.type}
    url = f"{BASE_URL}/api/v1/market/data/economic/us-economic?" + urllib.parse.urlencode(params)

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/etf-adjust-factor"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询 ETF 复权因子")
    parser.add_argument("--symbol")
    parser.add_argument("--trade-date")
    parser.add_argument("--start-date")
    parser.add_argument("--end-date")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", type=int, default=50)
    args = parser.parse_args()
    if args.page < 1 or not 1 <= args.page_size <= 2000:
        parser.error("page 须 >= 1，page-size 须在 1～2000 之间")
    if bool(args.start_date) != bool(args.end_date):
        parser.error("start-date 与 end-date 必须同时提供")
    if args.start_date and not args.symbol:
        parser.error("区间扫描必须提供 symbol")
    params = {"page": args.page, "page_size": args.page_size}
    for name in ("symbol", "trade_date", "start_date", "end_date"):
        value = getattr(args, name)
        if value:
            params[name] = value
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    request = urllib.request.Request(url, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""ETF 公告列表（GET /api/v2/market/data/announcements/etf-announcements）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/announcements/etf-announcements"

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_params(args):
    params = {"page": args.page, "page_size": args.page_size}
    if args.etf_code is not None:
        params["etf_code"] = args.etf_code
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    return params


def fetch_page(params):
    query = urllib.parse.urlencode(params)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(
        description="ETF 公告列表：按标的（--etf-code）或按单日日期（--start-date）查询"
    )
    parser.add_argument("--etf-code", dest="etf_code", default=None,
                        help="ETF 代码，支持裸代码/短后缀/长后缀，如 159915、159915.SZ、510300.XSHG")
    parser.add_argument("--start-date", dest="start_date", default=None,
                        help="日期 YYYYMMDD（按日期查询时必填，仅支持单日）")
    parser.add_argument("--end-date", dest="end_date", default=None,
                        help="日期 YYYYMMDD；不填默认等于 start_date，且必须等于 start_date")
    parser.add_argument("--page", type=int, required=True, help="页码（必填）")
    parser.add_argument("--page-size", dest="page_size", type=int, required=True, help="每页条数（必填）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    if args.etf_code is None and args.start_date is None:
        print("必须提供 --etf-code（按标的查）或 --start-date（按日期查）", file=sys.stderr)
        raise SystemExit(2)

    params = build_params(args)
    if args.fetch_all:
        first = fetch_page(params)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        total_pages = data.get("pages") or 1
        for page in range(2, total_pages + 1):
            page_data = fetch_page({**params, "page": page})
            records.extend((page_data.get("data") or {}).get("records", []))
        result = {
            "records": records,
            "pages": total_pages,
            "total": data.get("total", len(records)),
        }
    else:
        result = fetch_page(params)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for etf-announcements handler"""
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


def _run(argv):
    with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
        with patch.object(sys, "argv", ["handler.py"] + argv):
            with patch("sys.stdout", new_callable=StringIO) as out:
                handler.main()
                return json.loads(out.getvalue())


class TestModes(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_requires_code_or_date(self):
        with self.assertRaises(SystemExit):
            _run(["--page", "1", "--page-size", "5"])

    @patch.object(handler, "safe_urlopen")
    def test_by_symbol(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'{"code":200,"data":{"records":[],"pages":1,"total":0}}'
        )
        _run(["--etf-code", "159915", "--page", "1", "--page-size", "5"])
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v2/market/data/announcements/etf-announcements", req.full_url)
        self.assertIn("etf_code=159915", req.full_url)
        self.assertIn("page=1", req.full_url)
        self.assertIn("page_size=5", req.full_url)

    @patch.object(handler, "safe_urlopen")
    def test_by_single_date(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'{"code":200,"data":{"records":[],"pages":1,"total":0}}'
        )
        _run(["--start-date", "20260831", "--page", "1", "--page-size", "5"])
        req = mock_open.call_args[0][0]
        self.assertIn("start_date=20260831", req.full_url)
        self.assertNotIn("end_date", req.full_url)


class TestFetchAll(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_all_aggregates_pages(self, mock_open):
        page1 = {"code": 200, "data": {"records": [{"announcement_id": "1"}], "pages": 2, "total": 2}}
        page2 = {"code": 200, "data": {"records": [{"announcement_id": "2"}], "pages": 2, "total": 2}}
        mock_open.return_value.__enter__.return_value.read.side_effect = [
            json.dumps(page1).encode(), json.dumps(page2).encode(),
        ]
        result = _run(["--etf-code", "159915", "--page", "1", "--page-size", "1", "--all"])
        self.assertEqual([r["announcement_id"] for r in result["records"]], ["1", "2"])
        self.assertEqual(result["total"], 2)
        second_req = mock_open.call_args_list[1][0][0]
        self.assertIn("page=2", second_req.full_url)


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询单只 ETF 历史 K 线（GET /api/v1/market/data/etf-candlesticks）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/etf-candlesticks"

INTERVAL_UNITS = ("Minute", "Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def build_body(symbol, interval_unit, interval_value, adjust_kind,
               since_ts_millis, until_ts_millis, limit):
    body = {
        "symbol": symbol,
        "interval_unit": interval_unit,
        "until_ts_millis": until_ts_millis,
    }
    if interval_value is not None and interval_value != 1:
        body["interval_value"] = interval_value
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if since_ts_millis is not None:
        body["since_ts_millis"] = since_ts_millis
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(
symbol, interval_unit, interval_value, adjust_kind,
          since_ts_millis, until_ts_millis, limit):
    body = build_body(symbol, interval_unit, interval_value, adjust_kind,
                      since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    url = f"{BASE_URL}{ENDPOINT}?{query}"
    req = urllib.request.Request(
        url,
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        msg = e.read().decode()
        print(f"HTTP {e.code}: {msg}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只 ETF 历史 K 线（GET 查询参数）")
    parser.add_argument("--symbol", required=True, help="ETF 代码，如 510300.XSHG、159915.XSHE")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True,
                        choices=INTERVAL_UNITS, help="K 线周期：Minute/Day/Week/Month/Year")
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=1,
                        help="间隔数值，默认 1（Minute+5 表示 5 分钟 K）")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", type=int, default=None,
                        help="开始时间戳（毫秒）；分钟 K 与 until 跨度 ≤3 天")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None, help="返回条数上限")
    args = parser.parse_args()

    data = fetch(args.symbol, args.interval_unit, args.interval_value,
                 args.adjust_kind, args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for etf-candlesticks handler"""
import json
import sys
import unittest
import urllib.error
from io import BytesIO, StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestBuildBody(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_required_fields(self):
        b = handler.build_body("510300.XSHG", "Day", 1, "None", None, 1756791000000, None)
        self.assertEqual(b["symbol"], "510300.XSHG")
        self.assertEqual(b["interval_unit"], "Day")
        self.assertEqual(b["until_ts_millis"], 1756791000000)
        self.assertNotIn("interval_value", b)
        self.assertNotIn("adjust_kind", b)
        self.assertNotIn("since_ts_millis", b)
        self.assertNotIn("limit", b)

    def test_optional_fields(self):
        b = handler.build_body("510300.XSHG", "Minute", 5, "Forward",
                               1756700000000, 1756791000000, 100)
        self.assertEqual(b["interval_value"], 5)
        self.assertEqual(b["adjust_kind"], "Forward")
        self.assertEqual(b["since_ts_millis"], 1756700000000)
        self.assertEqual(b["limit"], 100)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_post_body_sent(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("510300.XSHG", "Day", 1, "None", None, 1756791000000, 5)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v1/market/data/etf-candlesticks", req.full_url)
        self.assertIsNone(req.data)
        self.assertEqual(req.full_url.split("?", 1)[1], "symbol=510300.XSHG&interval_unit=Day&until_ts_millis=1756791000000&limit=5")
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")
        self.assertEqual(req.headers.get("Content-type"), "application/json")

    @patch.object(handler, "safe_urlopen")
    def test_http_error_exits(self, mock_open):
        mock_open.side_effect = urllib.error.HTTPError(
            "https://fake", 500, "Internal Error", {}, BytesIO(b"server error")
        )
        with self.assertRaises(SystemExit):
            handler.fetch("510300.XSHG", "Day", 1, "None", None, 1756791000000, None)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'[{"open":"4.5","high":"4.6","low":"4.4","close":"4.55","ts_millis":1756710000000,'
            b'"ts_millis_open":1756690200000,"turnover":"100","volume":1000}]'
        )
        with patch.object(sys, "argv", [
            "handler.py", "--symbol", "510300.XSHG", "--interval-unit", "Day",
            "--until-ts-millis", "1756791000000", "--limit", "5"
        ]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                data = json.loads(fake_out.getvalue())
                self.assertEqual(len(data), 1)
                self.assertEqual(data[0]["close"], "4.55")

    def test_main_missing_until_exits(self):
        with patch.object(sys, "argv", [
            "handler.py", "--symbol", "510300.XSHG", "--interval-unit", "Day"
        ]):
            with self.assertRaises(SystemExit):
                handler.main()


class TestSafeUrlopen(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_rejects_wrong_host(self):
        with self.assertRaises(SystemExit):
            handler.safe_urlopen("https://evil.com/api")


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""批量查询多只 ETF K 线（GET /api/v2/market/data/etf-candlesticks/batch）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/etf-candlesticks/batch"

INTERVAL_UNITS = ("Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def parse_symbols(raw):
    syms = [s.strip() for s in raw.split(",") if s.strip()]
    if not syms:
        print("--symbols 不能为空", file=sys.stderr)
        sys.exit(1)
    return syms


def build_query(symbols, interval_unit, adjust_kind, since_ts_millis, until_ts_millis, limit):
    body = {
        "symbols": symbols,
        "interval_unit": interval_unit,
        "until_ts_millis": until_ts_millis,
    }
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if since_ts_millis is not None:
        body["since_ts_millis"] = since_ts_millis
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(symbols, interval_unit, adjust_kind, since_ts_millis, until_ts_millis, limit):
    body = build_query(symbols, interval_unit, adjust_kind, since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="批量获取多只 ETF 的历史 K 线（不支持分钟周期）")
    parser.add_argument("--symbols", required=True,
                        help="ETF 代码列表，逗号分隔，如 510300.XSHG,159915.XSHE；也接受 .SH/.SZ 短后缀")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True, type=str.capitalize,
                        choices=INTERVAL_UNITS, help="K 线周期：Day/Week/Month/Year（大小写不敏感，不支持 Minute）")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int,
                        help="开始时间戳（毫秒）；与结束时间跨度不得超过 12 个日历月")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None,
                        help="每个标的返回条数上限；不传时返回请求时间范围内的全部数据")
    args = parser.parse_args()

    if args.since_ts_millis > args.until_ts_millis:
        print("--since-ts-millis 不能晚于 --until-ts-millis", file=sys.stderr)
        raise SystemExit(2)

    symbols = parse_symbols(args.symbols)
    data = fetch(symbols, args.interval_unit, args.adjust_kind,
                 args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for etf-candlesticks-batch handler"""
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

SINCE = "1756431000000"
UNTIL = "1756791000000"


class TestBuildQuery(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_required_only(self):
        body = handler.build_query(["510300.SH"], "Day", "None", 1756431000000, 1756791000000, None)
        self.assertEqual(body["symbols"], ["510300.SH"])
        self.assertEqual(body["interval_unit"], "Day")
        self.assertEqual(body["since_ts_millis"], 1756431000000)
        self.assertEqual(body["until_ts_millis"], 1756791000000)
        self.assertNotIn("adjust_kind", body)
        self.assertNotIn("limit", body)
        self.assertNotIn("interval_value", body)

    def test_optional_fields(self):
        body = handler.build_query(["510300.SH", "159915.SZ"], "Week", "Forward",
                                   1756700000000, 1756791000000, 5)
        self.assertEqual(body["symbols"], ["510300.SH", "159915.SZ"])
        self.assertEqual(body["adjust_kind"], "Forward")
        self.assertEqual(body["limit"], 5)

    def test_minute_not_allowed(self):
        with self.assertRaises(SystemExit):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "510300.SH",
                                            "--interval-unit", "Minute",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                handler.main()


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_query_string_expands_symbols(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch(["510300.SH", "159915.SZ"], "Day", "None", 1756431000000, 1756791000000, 2)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v2/market/data/etf-candlesticks/batch", req.full_url)
        query = req.full_url.split("?", 1)[1]
        self.assertIn("symbols=510300.SH", query)
        self.assertIn("symbols=159915.SZ", query)
        self.assertIn("interval_unit=Day", query)
        self.assertIn("since_ts_millis=1756431000000", query)
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'{"code":200,"message":"success","data":[["510300.SH",'
            b'[{"open":4.55,"close":4.601,"ts_millis":"1756450800000"}]]]}'
        )
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "510300.SH",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL, "--limit", "2"]):
                with patch("sys.stdout", new_callable=StringIO) as out:
                    handler.main()
                    data = json.loads(out.getvalue())
                    self.assertEqual(data["data"][0][0], "510300.SH")

    def test_main_requires_since(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "510300.SH",
                                            "--interval-unit", "Day",
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_since_after_until(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "510300.SH",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", UNTIL,
                                            "--until-ts-millis", SINCE]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_requires_symbols(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--interval-unit", "Day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""ETF 成分证券明细（GET /api/v2/market/data/etf-component-details）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/etf-component-details"

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_params(args):
    params = {"symbol": args.symbol}
    if args.trade_date is not None:
        params["trade_date"] = args.trade_date
    return params


def fetch(params):
    query = urllib.parse.urlencode(params)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="按 ETF 和交易日查询申赎清单全部成分证券及数量")
    parser.add_argument("--symbol", required=True,
                        help="ETF 代码，如 510300.SH、159915.SZ")
    parser.add_argument("--trade-date", dest="trade_date", type=int, default=None,
                        help="交易日 YYYYMMDD；不传时查询该 ETF 最新可用交易日")
    args = parser.parse_args()

    print(json.dumps(fetch(build_params(args)), ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/etf-components-all"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=60):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询全部或单只 ETF 成份列表")
    parser.add_argument("--symbol")
    args = parser.parse_args()
    url = BASE_URL + ENDPOINT
    if args.symbol:
        url += "?" + urllib.parse.urlencode({"symbol": args.symbol})
    request = urllib.request.Request(url, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询全部 ETF 基础信息（market.ft.tech）"""
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    url = BASE_URL + "/api/v2/market/data/etf-description-all"
    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/etf_minutes"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询 ETF 历史分钟行情")
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=1)
    parser.add_argument("--adjust-kind", dest="adjust_kind")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int)
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int)
    parser.add_argument("--limit", type=int, default=50)
    args = parser.parse_args()
    if args.interval_value <= 0 or not 1 <= args.limit <= 1000:
        parser.error("interval-value 须大于 0，limit 须在 1～1000 之间")
    params = {"symbol": args.symbol, "interval_value": args.interval_value,
              "since_ts_millis": args.since_ts_millis, "until_ts_millis": args.until_ts_millis,
              "limit": args.limit}
    if args.adjust_kind is not None:
        params["adjust_kind"] = args.adjust_kind
    request = urllib.request.Request(BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params),
                                     headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse,json,os,sys,urllib.parse,urllib.request
BASE_URL=os.environ.get("FTSHARE_BASE_URL","https://market.ft.tech/gateway").rstrip("/");_REQUEST_HEADERS={"FTSHARE_API_KEY":os.environ.get("FTSHARE_API_KEY", ""),"Content-Type":"application/json"}; ENDPOINT="/api/v2/market/data/etf_minutes/batch"
def main():
 p=argparse.ArgumentParser(); p.add_argument("--symbols",required=True); p.add_argument("--since-ts-millis",required=True,type=int); p.add_argument("--until-ts-millis",required=True,type=int); p.add_argument("--interval-value",type=int,default=1); p.add_argument("--adjust-kind",choices=["None","Forward","Backward"],default="None"); p.add_argument("--limit",type=int,default=50); a=p.parse_args()
 if a.interval_value<1 or not 1<=a.limit<=1000:p.error("interval-value 须大于 0，limit 须在 1～1000 之间")
 key=os.environ.get("FTSHARE_API_KEY")
 if not key: print("FTSHARE_API_KEY environment variable is required",file=sys.stderr); raise SystemExit(2)
 params=[("symbols",s.strip()) for s in a.symbols.split(",") if s.strip()]+[("since_ts_millis",a.since_ts_millis),("until_ts_millis",a.until_ts_millis),("interval_value",a.interval_value),("limit",a.limit)]
 if a.adjust_kind!="None":params.append(("adjust_kind",a.adjust_kind))
 req=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params),headers={"FTSHARE_API_KEY":key,"Content-Type":"application/json"},method="GET")
 try:
  with urllib.request.urlopen(req,timeout=30) as r: print(json.dumps(json.loads(r.read().decode()),ensure_ascii=False,indent=2))
 except Exception as e: print(f"请求失败: {e}",file=sys.stderr); raise SystemExit(1)
if __name__=="__main__":main()

#!/usr/bin/env python3
"""ETF 历史净值（GET /api/v2/market/data/etf-net-value）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/etf-net-value"

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_params(args):
    params = {"etf_code": args.etf_code}
    if args.nav_date is not None:
        params["nav_date"] = args.nav_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    params["page"] = args.page
    params["page_size"] = args.page_size
    return params


def fetch_page(params):
    query = urllib.parse.urlencode(params)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="按 ETF 代码分页查询历史净值")
    parser.add_argument("--etf-code", dest="etf_code", required=True,
                        help="ETF 代码，如 510300")
    parser.add_argument("--nav-date", dest="nav_date", type=int, default=None,
                        help="净值日期 YYYYMMDD；与日期区间参数互斥，二者必须二选一")
    parser.add_argument("--start-date", dest="start_date", type=int, default=None,
                        help="净值开始日期 YYYYMMDD；须与 --end-date 同时提供")
    parser.add_argument("--end-date", dest="end_date", type=int, default=None,
                        help="净值结束日期 YYYYMMDD；须与 --start-date 同时提供")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始，默认 1")
    parser.add_argument("--page-size", dest="page_size", type=int, default=50,
                        help="每页条数，默认 50，最大 200")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    if args.nav_date is not None and (args.start_date is not None or args.end_date is not None):
        print("--nav-date 不能与 --start-date/--end-date 同时使用", file=sys.stderr)
        raise SystemExit(2)
    if args.nav_date is None and (args.start_date is None or args.end_date is None):
        print("必须提供 --nav-date，或同时提供 --start-date 和 --end-date", file=sys.stderr)
        raise SystemExit(2)

    params = build_params(args)
    if args.fetch_all:
        first = fetch_page(params)
        data = first.get("data") or {}
        items = list(data.get("items", []))
        total_pages = data.get("total_pages") or 1
        for page in range(2, total_pages + 1):
            page_data = fetch_page({**params, "page": page})
            items.extend((page_data.get("data") or {}).get("items", []))
        result = {
            "items": items,
            "total_pages": total_pages,
            "total_items": data.get("total_items", len(items)),
        }
    else:
        result = fetch_page(params)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for etf-net-value handler"""
import os
import sys
import unittest
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


def _run(argv):
    with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
        with patch.object(sys, "argv", ["handler.py"] + argv):
            handler.main()


class TestDateModes(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_requires_nav_date_or_range(self):
        with self.assertRaises(SystemExit):
            _run(["--etf-code", "510300", "--page", "1", "--page-size", "5"])

    def test_rejects_nav_date_with_range(self):
        with self.assertRaises(SystemExit):
            _run(["--etf-code", "510300", "--nav-date", "20260909",
                  "--start-date", "20260901", "--end-date", "20260909"])

    def test_rejects_partial_range(self):
        with self.assertRaises(SystemExit):
            _run(["--etf-code", "510300", "--start-date", "20260901"])

    @patch.object(handler, "safe_urlopen")
    def test_accepts_nav_date(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--etf-code", "510300", "--nav-date", "20260909"])
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v2/market/data/etf-net-value", req.full_url)
        self.assertIn("etf_code=510300", req.full_url)
        self.assertIn("nav_date=20260909", req.full_url)

    @patch.object(handler, "safe_urlopen")
    def test_accepts_range(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--etf-code", "510300", "--start-date", "20260901", "--end-date", "20260909"])
        req = mock_open.call_args[0][0]
        self.assertIn("start_date=20260901", req.full_url)
        self.assertIn("end_date=20260909", req.full_url)
        self.assertNotIn("nav_date", req.full_url)


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""ETF 申赎清单 PCF 汇总信息（GET /api/v2/market/data/etf-pcf/etf-pcf-infos）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/etf-pcf/etf-pcf-infos"

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_query(args):
    params = {}
    if args.symbol is not None:
        params["symbol"] = args.symbol
    if args.trade_date is not None:
        params["trade_date"] = args.trade_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params


def fetch(params):
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(
        description="ETF 申赎清单（PCF 汇总信息）：单标的单日 / 全市场单日分页 / 单标的日期区间"
    )
    parser.add_argument("--symbol", default=None, help="ETF 代码，如 510300.SH 或 510300.XSHG")
    parser.add_argument("--trade-date", dest="trade_date", type=int, default=None,
                        help="交易日 YYYYMMDD；单日查询时必填，不能与日期区间同用")
    parser.add_argument("--start-date", dest="start_date", type=int, default=None,
                        help="区间开始日期 YYYYMMDD；须与 --end-date、--symbol 同时提供")
    parser.add_argument("--end-date", dest="end_date", type=int, default=None,
                        help="区间结束日期 YYYYMMDD；须与 --start-date、--symbol 同时提供")
    parser.add_argument("--page", type=int, default=None, help="页码，从 1 开始，默认 1；分页查询有效")
    parser.add_argument("--page-size", dest="page_size", type=int, default=None,
                        help="每页条数，默认 50，最大 500；分页查询有效")
    args = parser.parse_args()

    if args.trade_date is not None and (args.start_date is not None or args.end_date is not None):
        print("--trade-date 不能与 --start-date/--end-date 同时使用", file=sys.stderr)
        raise SystemExit(2)

    print(json.dumps(fetch(build_query(args)), ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for etf-pcf-infos handler"""
import os
import sys
import unittest
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


def _run(argv):
    with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
        with patch.object(sys, "argv", ["handler.py"] + argv):
            handler.main()


class TestModes(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_rejects_trade_date_with_range(self):
        with self.assertRaises(SystemExit):
            _run(["--symbol", "510300.SH", "--trade-date", "20260909",
                  "--start-date", "20260901", "--end-date", "20260909"])

    @patch.object(handler, "safe_urlopen")
    def test_single_symbol_single_day(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--symbol", "510300.SH", "--trade-date", "20260909"])
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v2/market/data/etf-pcf/etf-pcf-infos", req.full_url)
        self.assertIn("symbol=510300.SH", req.full_url)
        self.assertIn("trade_date=20260909", req.full_url)

    @patch.object(handler, "safe_urlopen")
    def test_omits_unset_optionals(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--trade-date", "20260909"])
        req = mock_open.call_args[0][0]
        self.assertNotIn("symbol", req.full_url)
        self.assertNotIn("page", req.full_url)
        self.assertNotIn("page_size", req.full_url)

    @patch.object(handler, "safe_urlopen")
    def test_range_mode_keeps_paging(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--symbol", "510300.SH", "--start-date", "20260901",
              "--end-date", "20260909", "--page", "2", "--page-size", "5"])
        req = mock_open.call_args[0][0]
        self.assertIn("start_date=20260901", req.full_url)
        self.assertIn("page=2", req.full_url)
        self.assertIn("page_size=5", req.full_url)


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""获取指定日期 ETF PCF 列表（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="获取指定日期 ETF PCF 列表")
    parser.add_argument(
        "--date",
        required=True,
        type=int,
        help="日期，YYYYMMDD 整型，如 20260309",
    )
    parser.add_argument(
        "--page",
        type=int,
        default=1,
        help="页码，从 1 开始，默认 1",
    )
    parser.add_argument(
        "--page_size",
        type=int,
        default=20,
        help="每页记录数，默认 20，最大 100",
    )
    args = parser.parse_args()

    params = {"date": args.date, "page": args.page, "page_size": args.page_size}
    url = BASE_URL + "/api/v2/market/data/etf-pcf/etf-pcfs?" + urllib.parse.urlencode(params)
    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/etf-pre-data'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='ETF盘前数据')
    parser.add_argument("--date")
    args = parser.parse_args()
    params = {}
    if args.date is not None: params["date"] = args.date
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询单只 ETF 盘前数据（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只 ETF 盘前数据")
    parser.add_argument(
        "--symbol",
        required=True,
        help="ETF 标的代码，带交易所后缀，如 510300.XSHG、159915.XSHE",
    )
    parser.add_argument(
        "--date",
        type=int,
        default=None,
        help="交易日 YYYYMMDD，如 20260316；不传则使用当日（CST）",
    )
    args = parser.parse_args()

    params: dict = {"symbol": args.symbol}
    if args.date is not None:
        params["date"] = args.date

    path = "/api/v2/market/data/etf-pre-single?" + urllib.parse.urlencode(params)
    url = BASE_URL + path

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(body, file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v4/market/data/etf-realtime-day-kline"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询 ETF 实时日 K 线")
    parser.add_argument("--symbols", nargs="+", required=True)
    args = parser.parse_args()
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode({"symbols": json.dumps(args.symbols, ensure_ascii=False)})
    request = urllib.request.Request(url, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v4/market/data/etf-realtime-minute-kline"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询 ETF 实时分钟 K 线")
    parser.add_argument("--symbols", nargs="+", required=True)
    args = parser.parse_args()
    if len(args.symbols) > 20:
        parser.error("symbols 单次最多 20 个")
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode({"symbols": json.dumps(args.symbols, ensure_ascii=False)})
    request = urllib.request.Request(url, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""ETF 份额变动（GET /api/v2/market/data/etf-share）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/etf-share"

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}

STATI_PERD = ("日", "季度", "年度", "截止时点", "半年", "全部")


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_params(args):
    params = {"etf_code": args.etf_code}
    if args.stati_perd is not None:
        params["stati_perd"] = args.stati_perd
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    params["page"] = args.page
    params["page_size"] = args.page_size
    return params


def fetch_page(params):
    query = urllib.parse.urlencode(params)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="按 ETF 代码分页查询份额变动")
    parser.add_argument("--etf-code", dest="etf_code", required=True,
                        help="ETF 代码，如 510300")
    parser.add_argument("--stati-perd", dest="stati_perd", default=None, choices=STATI_PERD,
                        help="统计周期：日/季度/年度/截止时点/半年/全部；不传默认全部")
    parser.add_argument("--start-date", dest="start_date", type=int, default=None,
                        help="开始日期 YYYYMMDD，按 trade_date 过滤")
    parser.add_argument("--end-date", dest="end_date", type=int, default=None,
                        help="结束日期 YYYYMMDD，按 trade_date 过滤")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始，默认 1")
    parser.add_argument("--page-size", dest="page_size", type=int, default=50,
                        help="每页条数，默认 50，最大 200")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    params = build_params(args)
    if args.fetch_all:
        first = fetch_page(params)
        data = first.get("data") or {}
        items = list(data.get("items", []))
        total_pages = data.get("total_pages") or 1
        for page in range(2, total_pages + 1):
            page_data = fetch_page({**params, "page": page})
            items.extend((page_data.get("data") or {}).get("items", []))
        result = {
            "items": items,
            "total_pages": total_pages,
            "total_items": data.get("total_items", len(items)),
        }
    else:
        result = fetch_page(params)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/exchange-margin-summaries"
_REQUEST_HEADERS = {"X-Client-Name": "ft-claw", "Content-Type": "application/json"}
if os.environ.get("FTSHARE_API_KEY"):
    _REQUEST_HEADERS["FTSHARE_API_KEY"] = os.environ["FTSHARE_API_KEY"]
OPENER = urllib.request.build_opener()


def safe_urlopen(request):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    return OPENER.open(request, timeout=60)


def fetch(
page, page_size, start_date, end_date, exchange=None):
    params = {"start_date": start_date, "end_date": end_date, "page": page, "page_size": page_size}
    if exchange:
        params["exchange"] = exchange
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    try:
        with safe_urlopen(request) as response:
            return json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser()
    parser.add_argument("--start-date", required=True)
    parser.add_argument("--end-date", required=True)
    parser.add_argument("--exchange")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", type=int, default=100)
    parser.add_argument("--all", action="store_true", dest="fetch_all")
    args = parser.parse_args()
    result = fetch(args.page, args.page_size, args.start_date, args.end_date, args.exchange)
    if args.fetch_all:
        records = list(result.get("records", result.get("items", [])))
        pages = result.get("pages", result.get("total_pages", 1))
        for page in range(args.page + 1, pages + 1):
            next_page = fetch(page, args.page_size, args.start_date, args.end_date, args.exchange)
            records.extend(next_page.get("records", next_page.get("items", [])))
        result["records"] = records
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/holder/stock-ggmx"
_REQUEST_HEADERS = {
    "FTSHARE_API_KEY": os.environ.get("FTSHARE_API_KEY", ""),
    "Content-Type": "application/json",
}


def fetch(params):
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if (parsed.scheme, parsed.netloc) != (base.scheme, base.netloc):
        print("Invalid URL for safe_urlopen", file=sys.stderr)
        raise SystemExit(1)
    request = urllib.request.Request(
        url,
        headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key},
        method="GET",
    )
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            return json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


def main():
    parser = argparse.ArgumentParser(description="查询董监高持股变动")
    parser.add_argument("--stock-code", dest="stock_code")
    parser.add_argument("--change-direction", dest="change_direction")
    parser.add_argument("--start-date", dest="start_date")
    parser.add_argument("--end-date", dest="end_date")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)
    parser.add_argument("--all", action="store_true", dest="fetch_all")
    args = parser.parse_args()
    if args.page < 1 or not 1 <= args.page_size <= 200:
        parser.error("page 须大于等于 1，page-size 须在 1～200 之间")
    params = {
        "page": 1 if args.fetch_all else args.page,
        "page_size": args.page_size,
    }
    for name in ("stock_code", "change_direction", "start_date", "end_date"):
        value = getattr(args, name)
        if value is not None:
            params[name] = value
    result = fetch(params)
    if args.fetch_all:
        data = result.get("data") or {}
        records = list(data.get("records", []))
        for page in range(2, int(data.get("pages", 1)) + 1):
            records.extend((fetch({**params, "page": page}).get("data") or {}).get("records", []))
        result["data"] = {**data, "records": records}
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for executive-holdings-changes handler"""
import importlib.util
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "fetch")
    def test_fetch_contract(self, mock_fetch):
        mock_fetch.return_value = {
            "code": 200,
            "message": "ok",
            "data": {"pages": 1, "records": []},
        }
        with patch.object(sys, "argv", [
            "handler.py",
            "--stock-code", "600848",
            "--change-direction", "增持",
            "--start-date", "20260101",
            "--end-date", "20260601",
            "--page", "2",
            "--page-size", "20",
        ]):
            handler.main()
        params = mock_fetch.call_args.args[0]
        self.assertEqual(params, {
            "stock_code": "600848",
            "change_direction": "增持",
            "start_date": "20260101",
            "end_date": "20260601",
            "page": 2,
            "page_size": 20,
        })


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "fetch")
    def test_main_emits_json(self, mock_fetch):
        mock_fetch.return_value = {
            "code": 200,
            "message": "ok",
            "data": {"pages": 1, "records": []},
        }
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--stock-code", "600848"]):
                with patch("sys.stdout", new_callable=StringIO) as fake_out:
                    handler.main()
                    self.assertEqual(json.loads(fake_out.getvalue())["code"], 200)


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询百度财经日历。"""
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/finance/financial-calendar/baidu"


def safe_urlopen(req_or_url):
    url = req_or_url.full_url if isinstance(req_or_url, urllib.request.Request) else str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询百度财经日历")
    parser.add_argument("--start-date", required=True, help="开始日期，格式 YYYY-MM-DD")
    parser.add_argument("--end-date", required=True, help="结束日期，格式 YYYY-MM-DD")
    parser.add_argument(
        "--category",
        choices=("economic", "ipo", "report_time", "trade_reminder"),
        default=None,
        help="可选事件分类",
    )
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始")
    parser.add_argument("--page-size", dest="page_size", type=int, default=50, help="每页条数，最大 200")
    args = parser.parse_args()

    params = {
        "start_date": args.start_date,
        "end_date": args.end_date,
        "category": args.category,
        "page": args.page,
        "page_size": args.page_size,
    }
    query = urllib.parse.urlencode({key: value for key, value in params.items() if value is not None})
    request = urllib.request.Request(f"{BASE_URL}{ENDPOINT}?{query}", method="GET", headers=_REQUEST_HEADERS)

    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        body = error.read().decode().strip()
        message = f"HTTP {error.code}"
        if body:
            message += f": {body}"
        print(message, file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

from __future__ import annotations

import importlib.util
import io
import json
import sys
import urllib.error
from pathlib import Path
from urllib.parse import parse_qs, urlparse

import pytest


HANDLER = Path(__file__).with_name("handler.py")


def load_handler():
    spec = importlib.util.spec_from_file_location("financial_calendar_handler", HANDLER)
    module = importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    spec.loader.exec_module(module)
    return module


class Response:
    def __init__(self, payload):
        self.payload = payload

    def __enter__(self):
        return self

    def __exit__(self, *args):
        return None

    def read(self):
        return json.dumps(self.payload).encode()


def test_main_forwards_documented_query(monkeypatch, capsys):
    module = load_handler()
    opened = []
    monkeypatch.setattr(
        sys,
        "argv",
        [
            "handler.py",
            "--start-date",
            "2026-07-16",
            "--end-date",
            "2026-07-17",
            "--category",
            "economic",
            "--page",
            "1",
            "--page-size",
            "5",
        ],
    )
    monkeypatch.setattr(module, "safe_urlopen", lambda request: opened.append(request) or Response({"data": {"records": []}}))

    module.main()

    parsed = urlparse(opened[0].full_url)
    assert parsed.path == "/gateway/api/v1/market/data/finance/financial-calendar/baidu"
    assert parse_qs(parsed.query) == {
        "start_date": ["2026-07-16"],
        "end_date": ["2026-07-17"],
        "category": ["economic"],
        "page": ["1"],
        "page_size": ["5"],
    }
    assert json.loads(capsys.readouterr().out) == {"data": {"records": []}}


def test_empty_http_error_body_still_reports_status(monkeypatch, capsys):
    module = load_handler()
    monkeypatch.setattr(sys, "argv", ["handler.py", "--start-date", "2026-07-16", "--end-date", "2026-07-17"])
    error = urllib.error.HTTPError("https://example.invalid", 503, "unavailable", {}, io.BytesIO(b""))
    monkeypatch.setattr(module, "safe_urlopen", lambda request: (_ for _ in ()).throw(error))

    with pytest.raises(SystemExit):
        module.main()

    assert capsys.readouterr().err.strip() == "HTTP 503"

#!/usr/bin/env python3
"""基金资产配置"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-asset-allocation"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.report_date is not None:
        params["report_date"] = args.report_date
    if args.publish_date is not None:
        params["publish_date"] = args.publish_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金资产配置")
    parser.add_argument("--fund_code", required=True, help="基金代码")
    parser.add_argument("--report_date", type=int, required=False, help="报告期 YYYYMMDD（与 start/end 互斥）")
    parser.add_argument("--publish_date", type=int, required=False, help="发布日期 YYYYMMDD")
    parser.add_argument("--start_date", type=int, required=False, help="报告期起始日期（需与 end_date 同传）")
    parser.add_argument("--end_date", type=int, required=False, help="报告期结束日期")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-asset-allocation-single-fund-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.report_date = None
        args.publish_date = None
        args.start_date = None
        args.end_date = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-asset-allocation", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--report_date', '20260331']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""查询基金基础信息（分页）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询基金基础信息（分页）")
    parser.add_argument("--fund-code", default=None, help="6 位数字基金代码，如 000001；不传时返回全市场默认分页")
    parser.add_argument("--page", type=int, default=None, help="页码，从 1 开始（默认 1）")
    parser.add_argument("--page-size", type=int, default=None, help="每页记录数，默认 200，最大 500")
    args = parser.parse_args()

    params = {"fund_code": args.fund_code, "page": args.page, "page_size": args.page_size}
    params = {key: value for key, value in params.items() if value is not None}
    url = f"{BASE_URL}/api/v1/market/data/fund/fund-basicinfo?" + urllib.parse.urlencode(params)

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(body, file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询指定基金在指定区间的累计收益率时间序列"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

VALID_CAL_TYPES = ["1M", "3M", "6M", "1Y", "3Y", "5Y", "YTD"]


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询基金累计收益率")
    parser.add_argument("--fund-code", required=True, help="6 位数字基金代码，如 159619")
    parser.add_argument("--cal-type", required=True, choices=VALID_CAL_TYPES,
                        help="区间类型：1M / 3M / 6M / 1Y / 3Y / 5Y / YTD")
    args = parser.parse_args()

    params = {"fund_code": args.fund_code, "cal-type": args.cal_type}
    url = f"{BASE_URL}/api/v1/market/data/fund/fund-cal-return?" + urllib.parse.urlencode(params)

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(body, file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""基金分类"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-classification"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.classify_std is not None:
        params["classify_std"] = args.classify_std
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金分类")
    parser.add_argument("--fund_code", required=True, help="基金代码（trade_code 形式，如 000001 或 000001.OF）")
    parser.add_argument("--classify_std", required=False, help="分类标准：证监会基金分类/晨星基金分类/银河证券分类2017版，缺省全部")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-classification-single-fund handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.classify_std = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-classification", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--classify_std', '晨星基金分类']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金公司"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-company"

def build_params(args):
    params = {}
    if args.fund_company is not None:
        params["fund_company"] = args.fund_company
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金公司")
    parser.add_argument("--fund_company", required=False, help="基金公司名称，精确匹配")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-company-list-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_company = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-company", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_company', '华夏基金']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金费率"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-fee"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.charge_type is not None:
        params["charge_type"] = args.charge_type
    if args.client_type is not None:
        params["client_type"] = args.client_type
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金费率")
    parser.add_argument("--fund_code", required=True, help="基金代码（如 000001 或 000001.OF）")
    parser.add_argument("--charge_type", required=False, help="费率类型：日常申购费/日常赎回费/认购费/管理费/托管费/销售服务费")
    parser.add_argument("--client_type", required=False, help="客户类型：一般/机构/养老金/REITs")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-fee-single-fund-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.charge_type = None
        args.client_type = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-fee", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--charge_type', '日常申购费']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金持有人结构"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-holder-structure"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.report_type is not None:
        params["report_type"] = args.report_type
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金持有人结构")
    parser.add_argument("--fund_code", required=True, help="基金代码（如 000001 或 000001.OF）")
    parser.add_argument("--report_type", required=False, help="报告类型：年度报告/中期报告/上市公告书/基金合同生效公告，缺省全部")
    parser.add_argument("--start_date", type=int, required=False, help="报告期起始日期 YYYYMMDD")
    parser.add_argument("--end_date", type=int, required=False, help="报告期截止日期 YYYYMMDD")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-holder-structure-single-fund handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.report_type = None
        args.start_date = None
        args.end_date = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-holder-structure", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--report_type', '年度报告']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""指数跟踪基金"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v2/market/data/fund/index-fund"

def build_params(args):
    params = {}
    if args.index_code is not None:
        params["index_code"] = args.index_code
    if args.scope is not None:
        params["scope"] = args.scope
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="指数跟踪基金")
    parser.add_argument("--index_code", required=True, help="指数代码，支持裸码（如 000300）或带后缀（如 000300.SH）")
    parser.add_argument("--scope", required=False, help="all 全市场（默认）/ etf 仅场内 ETF")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-index-tracking-funds handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.index_code = '000300'
        args.scope = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v2/market/data/fund/index-fund", url)
        self.assertIn("index_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--index_code', '000300']
        argv += ['--scope', 'etf']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金列表"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-list"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.fund_type is not None:
        params["fund_type"] = args.fund_type
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金列表")
    parser.add_argument("--fund_code", required=False, help="基金代码，精确查单只")
    parser.add_argument("--fund_type", required=False, help="基金类型，精确匹配（股票型/混合型/债券型/货币型/保本型/其他型/REITs）")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-list-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = None
        args.fund_type = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-list", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_type', '股票型']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金经理任职关系"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-manager"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.fund_manager is not None:
        params["fund_manager"] = args.fund_manager
    if args.is_inoffice is not None:
        params["is_inoffice"] = args.is_inoffice
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金经理任职关系")
    parser.add_argument("--fund_code", required=False, help="基金代码（与 fund_manager 二选一）")
    parser.add_argument("--fund_manager", required=False, help="基金经理姓名（与 fund_code 二选一）")
    parser.add_argument("--is_inoffice", required=False, help="1 在任 / 0 离任")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-manager-relationship handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = None
        args.fund_manager = None
        args.is_inoffice = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-manager", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--is_inoffice', '1']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金净值明细"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-net-value"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.nav_date is not None:
        params["nav_date"] = args.nav_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金净值明细")
    parser.add_argument("--fund_code", required=True, help="基金代码")
    parser.add_argument("--nav_date", type=int, required=False, help="净值日期 YYYYMMDD（与 start/end 互斥）")
    parser.add_argument("--start_date", type=int, required=False, help="净值开始日期 YYYYMMDD（需与 end_date 同传）")
    parser.add_argument("--end_date", type=int, required=False, help="净值结束日期 YYYYMMDD")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-net-value-detail-single-fund handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.nav_date = None
        args.start_date = None
        args.end_date = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-net-value", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--start_date', '20260101']
        argv += ['--end_date', '20260717']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金净值收益表现"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-net-value-performance"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.stat_date is not None:
        params["stat_date"] = args.stat_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金净值收益表现")
    parser.add_argument("--fund_code", required=True, help="基金代码")
    parser.add_argument("--stat_date", type=int, required=False, help="统计日期 YYYYMMDD（与 start/end 互斥）")
    parser.add_argument("--start_date", type=int, required=False, help="统计开始日期（需与 end_date 同传）")
    parser.add_argument("--end_date", type=int, required=False, help="统计结束日期")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-net-value-performance-single-fund handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.stat_date = None
        args.start_date = None
        args.end_date = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-net-value-performance", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--start_date', '20260101']
        argv += ['--end_date', '20260717']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金新发"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-new-found"

def build_params(args):
    params = {}
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.fund_type is not None:
        params["fund_type"] = args.fund_type
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金新发")
    parser.add_argument("--start_date", type=int, required=False, help="成立日起始日期 YYYYMMDD（不传默认近 1 年）")
    parser.add_argument("--end_date", type=int, required=False, help="成立日截止日期 YYYYMMDD（不传默认今天）")
    parser.add_argument("--fund_type", required=False, help="基金类型过滤：混合型/债券型/股票型/货币型/其他型/保本型/REITs")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-new-found-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.start_date = None
        args.end_date = None
        args.fund_type = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-new-found", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_type', '混合型']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""查询所有基金概览信息（分页）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询所有基金概览信息（分页）")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始（默认 1）")
    parser.add_argument("--page-size", type=int, default=20, help="每页记录数，最大 1000（默认 20）")
    args = parser.parse_args()

    params = {"page": args.page, "page_size": args.page_size}
    url = f"{BASE_URL}/api/v1/market/data/fund/fund-overview?" + urllib.parse.urlencode(params)

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(body, file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""基金持仓明细"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-portfolio"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.report_date is not None:
        params["report_date"] = args.report_date
    if args.publish_date is not None:
        params["publish_date"] = args.publish_date
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金持仓明细")
    parser.add_argument("--fund_code", required=True, help="基金代码")
    parser.add_argument("--report_date", type=int, required=False, help="报告期 YYYYMMDD（与 start/end 互斥）")
    parser.add_argument("--publish_date", type=int, required=False, help="发布日期 YYYYMMDD")
    parser.add_argument("--start_date", type=int, required=False, help="报告期起始日期（需与 end_date 同传）")
    parser.add_argument("--end_date", type=int, required=False, help="报告期结束日期")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-portfolio-single-fund-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.report_date = None
        args.publish_date = None
        args.start_date = None
        args.end_date = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-portfolio", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--report_date', '20260331']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金风险等级"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-risk-level"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.history:
        params["history"] = "true"
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金风险等级")
    parser.add_argument("--fund_code", required=True, help="基金代码（如 000001 或 000001.OF）")
    parser.add_argument("--history", action="store_true", help="返回全部变更历史（缺省仅当前有效）")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-risk-level-single-fund handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.history = False
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-risk-level", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--history']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""基金份额"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/fund/fund-share"

def build_params(args):
    params = {}
    if args.fund_code is not None:
        params["fund_code"] = args.fund_code
    if args.stati_perd is not None:
        params["stati_perd"] = args.stati_perd
    if args.start_date is not None:
        params["start_date"] = args.start_date
    if args.end_date is not None:
        params["end_date"] = args.end_date
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size
    return params

def fetch(
args):
    params = urllib.parse.urlencode(build_params(args))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)

def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="基金份额")
    parser.add_argument("--fund_code", required=True, help="基金代码")
    parser.add_argument("--stati_perd", required=False, help="统计周期：日/季度/年度/截止时点/半年/全部，默认日")
    parser.add_argument("--start_date", type=int, required=False, help="开始日期 YYYYMMDD（按 trade_date 过滤）")
    parser.add_argument("--end_date", type=int, required=False, help="结束日期 YYYYMMDD")
    parser.add_argument("--page", type=int, required=False, help="页码，默认 1")
    parser.add_argument("--page_size", type=int, required=False, help="每页记录数，默认 50，上限 200")
    args = parser.parse_args()

    result = fetch(args)
    print(json.dumps(result, ensure_ascii=False, indent=2))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for fund-share-single-fund-paginated handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_fetch_forwards_to_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        class Args: pass
        args = Args()
        args.fund_code = '000001'
        args.stati_perd = None
        args.start_date = None
        args.end_date = None
        args.page = None
        args.page_size = None
        handler.fetch(args)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/fund/fund-share", url)
        self.assertIn("fund_code=", url)

class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, 'safe_urlopen')
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'[]'
        argv = ['handler.py']
        argv += ['--fund_code', '000001']
        argv += ['--stati_perd', '日']
        argv += ['--start_date', '20260101']
        argv += ['--end_date', '20260717']
        argv += ['--page', '1']
        argv += ['--page_size', '50']
        with patch.object(sys, 'argv', argv):
            with patch('sys.stdout', new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python3
"""查询所有支持基金的标的列表（分页）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询所有支持基金标的列表（分页）")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始（默认 1）")
    parser.add_argument("--page-size", type=int, default=20, help="每页记录数，最大 1000（默认 20）")
    args = parser.parse_args()

    params = {"page": args.page, "page_size": args.page_size}
    url = f"{BASE_URL}/api/v1/market/data/fund/fund-support-symbols?" + urllib.parse.urlencode(params)

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(body, file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/futures-base-data'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='中国期货基础数据')
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--symbol", dest="symbol")
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""期货行情：期货合约日/周/月/季/年 K 线（GET /api/v1/market/data/futures/kline）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/futures/kline"

INTERVALS = (
    "daily", "1d",
    "weekly", "1w", "week",
    "monthly", "1mo", "month",
    "quarterly", "1q", "quarter",
    "yearly", "1y", "year",
)

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def build_params(args):
    params = {
        "symbol": args.symbol,
        "interval": args.interval,
    }
    if args.start is not None:
        params["start"] = args.start
    if args.end is not None:
        params["end"] = args.end
    if args.limit is not None:
        params["limit"] = args.limit
    return params


def fetch(params):
    query = urllib.parse.urlencode(params)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询期货合约日/周/月/季/年 K 线")
    parser.add_argument("--symbol", required=True,
                        help="期货合约代码，如 A2605.DCE；支持交易所短后缀")
    parser.add_argument("--interval", default="daily", choices=INTERVALS,
                        help="K 线周期，默认 daily；周/月/季/年 K 基于日 K 按北京时间聚合")
    parser.add_argument("--start", type=int, default=None,
                        help="起始时间戳（毫秒，闭区间）；可省略时间范围")
    parser.add_argument("--end", type=int, default=None,
                        help="结束时间戳（毫秒，闭区间）；不能单独传入")
    parser.add_argument("--limit", type=int, default=None,
                        help="返回条数，默认 500；最小值 1，传 0 时按 1 处理")
    args = parser.parse_args()

    if args.end is not None and args.start is None:
        print("--end 不能单独传入，必须与 --start 同时使用", file=sys.stderr)
        raise SystemExit(2)

    print(json.dumps(fetch(build_params(args)), ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for futures-contract-kline handler"""
import os
import sys
import unittest
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


def _run(argv):
    with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
        with patch.object(sys, "argv", ["handler.py"] + argv):
            handler.main()


class TestParams(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_rejects_end_without_start(self):
        with self.assertRaises(SystemExit):
            _run(["--symbol", "A2605.DCE", "--end", "1756791000000"])

    @patch.object(handler, "safe_urlopen")
    def test_defaults(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--symbol", "A2605.DCE"])
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/futures/kline", req.full_url)
        self.assertIn("symbol=A2605.DCE", req.full_url)
        self.assertIn("interval=daily", req.full_url)
        self.assertNotIn("limit", req.full_url)
        self.assertNotIn("start", req.full_url)

    @patch.object(handler, "safe_urlopen")
    def test_weekly_interval(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--symbol", "A2605.DCE", "--interval", "weekly", "--limit", "5",
              "--start", "1756431000000", "--end", "1756791000000"])
        req = mock_open.call_args[0][0]
        self.assertIn("interval=weekly", req.full_url)
        self.assertIn("limit=5", req.full_url)
        self.assertIn("start=1756431000000", req.full_url)
        self.assertIn("end=1756791000000", req.full_url)

    def test_rejects_unknown_interval(self):
        with self.assertRaises(SystemExit):
            _run(["--symbol", "A2605.DCE", "--interval", "minute"])


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/ft-limit'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='期货合约涨跌停价')
    parser.add_argument("--ts-code", dest="ts_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--start-date", dest="start_date", type=int)
    parser.add_argument("--end-date", dest="end_date", type=int)
    parser.add_argument("--cont", dest="cont")
    parser.add_argument("--exchange", dest="exchange")
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/futures-lists'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='中国期货列表')
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/fut-settle'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='期货每日结算参数')
    parser.add_argument("--ts-code", dest="ts_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--start-date", dest="start_date", type=int)
    parser.add_argument("--end-date", dest="end_date", type=int)
    parser.add_argument("--exchange", dest="exchange")
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/fut-wsr'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='期货仓单日报')
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--start-date", dest="start_date", type=int)
    parser.add_argument("--end-date", dest="end_date", type=int)
    parser.add_argument("--symbol", dest="symbol")
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/fut-weekly-detail'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key=os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url=request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed,base=urllib.parse.urlparse(url),urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request=urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key=_require_api_key(); parser=argparse.ArgumentParser(description='期货主要品种交易周报')
    parser.add_argument("--week", dest="week")
    parser.add_argument("--prd", dest="prd")
    parser.add_argument("--start-week", dest="start_week")
    parser.add_argument("--end-week", dest="end_week")
    parser.add_argument("--exchange", dest="exchange")
    parser.add_argument("--page", dest="page", type=int)
    parser.add_argument("--page-size", dest="page_size", type=int)
    ns=parser.parse_args(); params={}
    for name,value in vars(ns).items():
        if value is not None: params[name.replace("_","-") if False else name]=value
    request=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params), headers={"FTSHARE_API_KEY":key,"X-Client-Name":"ft-claw","Content-Type":"application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload=json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/global-index/daily-kline'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='全球指数日K线')
    parser.add_argument("--secid", required=True)
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--limit")
    parser.add_argument("--total", required=False)
    parser.add_argument("--items", required=False)
    parser.add_argument("--name", required=True)
    parser.add_argument("--trade_date", required=True)
    parser.add_argument("--open", required=False)
    parser.add_argument("--close", required=False)
    parser.add_argument("--high", required=False)
    parser.add_argument("--low", required=False)
    parser.add_argument("--volume", required=False)
    parser.add_argument("--amount", required=False)
    parser.add_argument("--amplitude", required=True)
    parser.add_argument("--change_pct", required=False)
    parser.add_argument("--change_amount", required=False)
    parser.add_argument("--turnover", required=False)
    args = parser.parse_args()
    params = {}
    if args.secid is not None: params["secid"] = args.secid
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.limit is not None: params["limit"] = args.limit
    if args.total is not None: params["total"] = args.total
    if args.items is not None: params["items"] = args.items
    if args.name is not None: params["name"] = args.name
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.open is not None: params["open"] = args.open
    if args.close is not None: params["close"] = args.close
    if args.high is not None: params["high"] = args.high
    if args.low is not None: params["low"] = args.low
    if args.volume is not None: params["volume"] = args.volume
    if args.amount is not None: params["amount"] = args.amount
    if args.amplitude is not None: params["amplitude"] = args.amplitude
    if args.change_pct is not None: params["change_pct"] = args.change_pct
    if args.change_amount is not None: params["change_amount"] = args.change_amount
    if args.turnover is not None: params["turnover"] = args.turnover
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/hibor-daily'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='HIBOR日度利率')
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--trade_date", required=True)
    parser.add_argument("--on_rate", required=False)
    args = parser.parse_args()
    params = {}
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.on_rate is not None: params["on_rate"] = args.on_rate
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询港股 K 线（market.ft.tech）"""
import argparse
import json
import re
import sys
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime, timedelta, timezone
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

INTERVAL_UNITS = ("day", "month", "quarter", "year")
ADJUST_KINDS = ("forward", "none")

BEIJING_TZ = timezone(timedelta(hours=8))
DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def _validate_date(value: str, name: str) -> str:
    """校验 YYYY-MM-DD 格式；若传入时带时间/时区则截取日期部分（东八区）。"""
    v = value.strip()
    if DATE_RE.match(v):
        return v
    try:
        raw = v
        if raw.endswith("Z"):
            raw = raw[:-1] + "+00:00"
        dt = datetime.fromisoformat(raw)
        if dt.tzinfo is None:
            dt = dt.replace(tzinfo=BEIJING_TZ)
        else:
            dt = dt.astimezone(BEIJING_TZ)
        return dt.strftime("%Y-%m-%d")
    except ValueError:
        print(f"{name} 格式错误，需为 YYYY-MM-DD：{value}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询港股 K 线")
    parser.add_argument(
        "--trade-code",
        dest="trade_code",
        required=True,
        help="港股代码，如 00700.HK 或 700；响应统一为 5 位 + .HK",
    )
    parser.add_argument(
        "--interval-unit",
        dest="interval_unit",
        required=True,
        choices=INTERVAL_UNITS,
        help="K 线间隔：day / month / quarter / year",
    )
    parser.add_argument(
        "--until-date",
        dest="until_date",
        required=True,
        help="结束日期，YYYY-MM-DD（东八区交易日）",
    )
    parser.add_argument(
        "--since-date",
        dest="since_date",
        default=None,
        help="开始日期，YYYY-MM-DD；不传则从库中最早数据起",
    )
    parser.add_argument(
        "--adjust-kind",
        dest="adjust_kind",
        default="forward",
        choices=ADJUST_KINDS,
        help="复权类型：forward（前复权，默认）或 none（不复权）",
    )
    parser.add_argument(
        "--interval-value",
        dest="interval_value",
        type=int,
        default=1,
        help="间隔数值，当前仅支持 1（默认 1）",
    )
    parser.add_argument(
        "--limit",
        type=int,
        default=None,
        help="返回条数上限；日 K 在 SQL 层下推，月/季/年聚合后截取最近 N 根",
    )
    args = parser.parse_args()

    until_date = _validate_date(args.until_date, "--until-date")
    since_date = None
    if args.since_date is not None and args.since_date.strip():
        since_date = _validate_date(args.since_date, "--since-date")

    params = {
        "trade_code": args.trade_code.strip(),
        "interval_unit": args.interval_unit,
        "until_date": until_date.replace("-", ""),
        "adjust_kind": args.adjust_kind,
        "interval_value": args.interval_value,
    }
    if since_date is not None:
        params["since_date"] = since_date.replace("-", "")
    if args.limit is not None:
        params["limit"] = args.limit

    path = "/api/v2/market/data/hk/hk-candlesticks"
    url = BASE_URL + path + "?" + urllib.parse.urlencode(params)

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询恒生系列指数成分股权重（HSI/HSCEI/HSAIT 等），按交易日/日期范围/指数/股票"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/hk/hsi-daily-weight"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def fetch_page(page: int, page_size: int, **extra) -> dict:
    params = {"page": page, "page_size": page_size}
    params.update({k: v for k, v in extra.items() if v is not None})
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="查询恒生系列指数成分股权重")
    parser.add_argument("--trade_date", type=int, default=None, help="交易日 YYYYMMDD；与 start_date/end_date 互斥")
    parser.add_argument("--start_date", type=int, default=None, help="交易日下界 YYYYMMDD；须与 end_date 同时提供")
    parser.add_argument("--end_date", type=int, default=None, help="交易日上界 YYYYMMDD；须与 start_date 同时提供")
    parser.add_argument("--index_slug", type=str, default=None,
                        help="指数代码，大小写不敏感：HSI(恒生)/HSCEI(国企)/HSAIT(恒生科技)")
    parser.add_argument("--stock_code", type=str, default=None, help="4 位港股代码，如 0700(腾讯)")
    parser.add_argument("--page", type=int, default=1, help="页码（默认 1）")
    parser.add_argument("--page_size", type=int, default=50, help="每页条数（默认 50，最大 200）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量")
    args = parser.parse_args()

    # trade_date 与 start/end 互斥
    if args.trade_date is not None and (args.start_date is not None or args.end_date is not None):
        print("错误：--trade_date 不可与 --start_date/--end_date 同时使用", file=sys.stderr)
        sys.exit(1)
    # start/end 必须成对
    if (args.start_date is None) != (args.end_date is None):
        print("错误：--start_date 与 --end_date 必须同时提供", file=sys.stderr)
        sys.exit(1)
    # 至少一个过滤条件
    if not (args.trade_date or args.start_date or args.index_slug or args.stock_code):
        print("错误：至少需要一个过滤条件：--trade_date / --start_date+--end_date / --index_slug / --stock_code", file=sys.stderr)
        sys.exit(1)

    extra = dict(trade_date=args.trade_date, start_date=args.start_date, end_date=args.end_date,
                 index_slug=args.index_slug, stock_code=args.stock_code)

    if args.fetch_all:
        first = fetch_page(1, args.page_size, **extra)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        pages = data.get("pages", 1)
        for p in range(2, pages + 1):
            d = fetch_page(p, args.page_size, **extra).get("data") or {}
            records.extend(d.get("records", []))
        result = {
            "code": first.get("code"), "message": first.get("message"),
            "data": {"pageNum": 1, "pageSize": args.page_size,
                     "total": data.get("total", len(records)), "pages": pages, "records": records},
        }
    else:
        result = fetch_page(args.page, args.page_size, **extra)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询单只指数历史 K 线（GET /api/v1/market/data/index-candlesticks）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/index-candlesticks"

INTERVAL_UNITS = ("Minute", "Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def build_body(symbol, interval_unit, interval_value, adjust_kind,
               since_ts_millis, until_ts_millis, limit):
    body = {
        "symbol": symbol,
        "interval_unit": interval_unit,
        "until_ts_millis": until_ts_millis,
    }
    if interval_value is not None and interval_value != 1:
        body["interval_value"] = interval_value
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if since_ts_millis is not None:
        body["since_ts_millis"] = since_ts_millis
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(
symbol, interval_unit, interval_value, adjust_kind,
          since_ts_millis, until_ts_millis, limit):
    body = build_body(symbol, interval_unit, interval_value, adjust_kind,
                      since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    url = f"{BASE_URL}{ENDPOINT}?{query}"
    req = urllib.request.Request(
        url,
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        msg = e.read().decode()
        print(f"HTTP {e.code}: {msg}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只指数历史 K 线（GET 查询参数）")
    parser.add_argument("--symbol", required=True, help="指数代码，如 000300.XSHG、399001.XSHE")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True,
                        choices=INTERVAL_UNITS, help="K 线周期：Minute/Day/Week/Month/Year")
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=1,
                        help="间隔数值，默认 1（Minute+5 表示 5 分钟 K）")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", type=int, default=None,
                        help="开始时间戳（毫秒）；分钟 K 与 until 跨度 ≤3 天")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None, help="返回条数上限")
    args = parser.parse_args()

    data = fetch(args.symbol, args.interval_unit, args.interval_value,
                 args.adjust_kind, args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for index-candlesticks handler"""
import json
import sys
import unittest
import urllib.error
from io import BytesIO, StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_get_to_index_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("000300.XSHG", "Day", 1, "None", None, 1756791000000, 5)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v1/market/data/index-candlesticks", req.full_url)
        self.assertIsNone(req.data)
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")

    @patch.object(handler, "safe_urlopen")
    def test_http_error_exits(self, mock_open):
        mock_open.side_effect = urllib.error.HTTPError(
            "https://fake", 500, "Internal Error", {}, BytesIO(b"server error")
        )
        with self.assertRaises(SystemExit):
            handler.fetch("000300.XSHG", "Day", 1, "None", None, 1756791000000, None)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.object(sys, "argv", [
            "handler.py", "--symbol", "000300.XSHG", "--interval-unit", "Day",
            "--until-ts-millis", "1756791000000"
        ]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""批量查询多个指数 K 线（GET /api/v2/market/data/index-candlesticks/batch）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v2/market/data/index-candlesticks/batch"

INTERVAL_UNITS = ("Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")

HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def parse_symbols(raw):
    syms = [s.strip() for s in raw.split(",") if s.strip()]
    if not syms:
        print("--symbols 不能为空", file=sys.stderr)
        sys.exit(1)
    return syms


def build_query(symbols, interval_unit, adjust_kind, since_ts_millis, until_ts_millis, limit):
    body = {
        "symbols": symbols,
        "interval_unit": interval_unit,
        "until_ts_millis": until_ts_millis,
    }
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if since_ts_millis is not None:
        body["since_ts_millis"] = since_ts_millis
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(symbols, interval_unit, adjust_kind, since_ts_millis, until_ts_millis, limit):
    body = build_query(symbols, interval_unit, adjust_kind, since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    req = urllib.request.Request(
        f"{BASE_URL}{ENDPOINT}?{query}",
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code}: {e.read().decode()}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="批量获取多个指数的历史 K 线（不支持分钟周期）")
    parser.add_argument("--symbols", required=True,
                        help="指数代码列表，逗号分隔，如 000300.XSHG,399001.XSHE；也接受 .SH/.SZ 短后缀")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True, type=str.capitalize,
                        choices=INTERVAL_UNITS, help="K 线周期：Day/Week/Month/Year（大小写不敏感，不支持 Minute）")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int,
                        help="开始时间戳（毫秒）；与结束时间跨度不得超过 12 个日历月")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None,
                        help="每个标的返回条数上限；不传时返回请求时间范围内的全部数据")
    args = parser.parse_args()

    if args.since_ts_millis > args.until_ts_millis:
        print("--since-ts-millis 不能晚于 --until-ts-millis", file=sys.stderr)
        raise SystemExit(2)

    symbols = parse_symbols(args.symbols)
    data = fetch(symbols, args.interval_unit, args.adjust_kind,
                 args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for index-candlesticks-batch handler"""
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)

SINCE = "1756431000000"
UNTIL = "1756791000000"


class TestBuildQuery(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_required_only(self):
        body = handler.build_query(["000300.SH"], "Day", "None", 1756431000000, 1756791000000, None)
        self.assertEqual(body["symbols"], ["000300.SH"])
        self.assertEqual(body["interval_unit"], "Day")
        self.assertEqual(body["since_ts_millis"], 1756431000000)
        self.assertNotIn("adjust_kind", body)
        self.assertNotIn("limit", body)
        self.assertNotIn("interval_value", body)

    def test_minute_not_allowed(self):
        with self.assertRaises(SystemExit):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "000300.SH",
                                            "--interval-unit", "Minute",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                handler.main()


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_targets_index_route(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'{"code":200,"message":"success","data":[["000300.SH",[]]]}'
        )
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "000300.SH,399001.SZ",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with patch("sys.stdout", new_callable=StringIO) as out:
                    handler.main()
                    data = json.loads(out.getvalue())
                    self.assertEqual(data["data"][0][0], "000300.SH")
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v2/market/data/index-candlesticks/batch", req.full_url)
        self.assertIn("since_ts_millis=1756431000000", req.full_url)

    def test_main_requires_since(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "000300.SH",
                                            "--interval-unit", "Day",
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()

    def test_main_rejects_since_after_until(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "000300.SH",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", UNTIL,
                                            "--until-ts-millis", SINCE]):
                with self.assertRaises(SystemExit):
                    handler.main()

    @patch.object(handler, "safe_urlopen")
    def test_interval_unit_case_insensitive(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", "000300.SH",
                                            "--interval-unit", "day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                handler.main()
        req = mock_open.call_args[0][0]
        self.assertIn("interval_unit=Day", req.full_url)

    def test_main_rejects_empty_symbols(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--symbols", " , ",
                                            "--interval-unit", "Day",
                                            "--since-ts-millis", SINCE,
                                            "--until-ts-millis", UNTIL]):
                with self.assertRaises(SystemExit):
                    handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询全部指数基础信息（market.ft.tech）"""
import json
import sys
import urllib.error
import urllib.request
import urllib.parse
import os


def safe_urlopen(req, timeout=30):
    url = req.full_url if isinstance(req, urllib.request.Request) else str(req)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req, urllib.request.Request):
        req = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        req.add_unredirected_header(key, value)
    return SAFE_URLOPENER.open(req, timeout=timeout)

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/index-description-all"


def main():
    _require_api_key()
    url = BASE_URL + ENDPOINT
    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("X-Client-Name", "ft-claw")
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""分页查询指数描述列表（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os


def safe_urlopen(req, timeout=30):
    url = req.full_url if isinstance(req, urllib.request.Request) else str(req)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req, urllib.request.Request):
        req = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        req.add_unredirected_header(key, value)
    return SAFE_URLOPENER.open(req, timeout=timeout)

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/index/index_description"


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="分页查询指数描述列表")
    parser.add_argument(
        "--page",
        type=int,
        default=1,
        help="页码，从 1 开始，默认 1",
    )
    parser.add_argument(
        "--page-size",
        dest="page_size",
        type=int,
        default=20,
        help="每页条数，默认 20，最大 100",
    )
    args = parser.parse_args()

    if args.page < 1:
        print("page 须 >= 1", file=sys.stderr)
        sys.exit(1)
    if args.page_size < 1 or args.page_size > 100:
        print("page_size 须在 1～100 之间", file=sys.stderr)
        sys.exit(1)

    params = {"page": args.page, "page_size": args.page_size}
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("X-Client-Name", "ft-claw")
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"请求失败: {e.reason}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/index_minutes"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询指数历史分钟行情")
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=1)
    parser.add_argument("--adjust-kind", dest="adjust_kind")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", required=True, type=int)
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int)
    parser.add_argument("--limit", type=int, default=50)
    args = parser.parse_args()
    if args.interval_value <= 0 or not 1 <= args.limit <= 1000:
        parser.error("interval-value 须大于 0，limit 须在 1～1000 之间")
    params = {"symbol": args.symbol, "interval_value": args.interval_value,
              "since_ts_millis": args.since_ts_millis, "until_ts_millis": args.until_ts_millis,
              "limit": args.limit}
    if args.adjust_kind is not None:
        params["adjust_kind"] = args.adjust_kind
    request = urllib.request.Request(BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params),
                                     headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse,json,os,sys,urllib.parse,urllib.request
BASE_URL=os.environ.get("FTSHARE_BASE_URL","https://market.ft.tech/gateway").rstrip("/");_REQUEST_HEADERS={"FTSHARE_API_KEY":os.environ.get("FTSHARE_API_KEY", ""),"Content-Type":"application/json"}; ENDPOINT="/api/v2/market/data/index_minutes/batch"
def main():
 p=argparse.ArgumentParser(); p.add_argument("--symbols",required=True); p.add_argument("--since-ts-millis",required=True,type=int); p.add_argument("--until-ts-millis",required=True,type=int); p.add_argument("--interval-value",type=int,default=1); p.add_argument("--adjust-kind",choices=["None","Forward","Backward"],default="None"); p.add_argument("--limit",type=int,default=50); a=p.parse_args()
 if a.interval_value<1 or not 1<=a.limit<=1000:p.error("interval-value 须大于 0，limit 须在 1～1000 之间")
 key=os.environ.get("FTSHARE_API_KEY")
 if not key: print("FTSHARE_API_KEY environment variable is required",file=sys.stderr); raise SystemExit(2)
 params=[("symbols",s.strip()) for s in a.symbols.split(",") if s.strip()]+[("since_ts_millis",a.since_ts_millis),("until_ts_millis",a.until_ts_millis),("interval_value",a.interval_value),("limit",a.limit)]
 if a.adjust_kind!="None":params.append(("adjust_kind",a.adjust_kind))
 req=urllib.request.Request(BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode(params),headers={"FTSHARE_API_KEY":key,"Content-Type":"application/json"},method="GET")
 try:
  with urllib.request.urlopen(req,timeout=30) as r: print(json.dumps(json.loads(r.read().decode()),ensure_ascii=False,indent=2))
 except Exception as e: print(f"请求失败: {e}",file=sys.stderr); raise SystemExit(1)
if __name__=="__main__":main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v4/market/data/index-realtime-day-kline'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='查询指数实时日 K 线')
    parser.add_argument("--symbols", nargs="+", required=True)

    args = parser.parse_args()
    params = {"symbols": json.dumps(args.symbols, ensure_ascii=False)}

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v4/market/data/index-realtime-minute-kline'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='查询指数实时分钟 K 线')
    parser.add_argument("--symbols", nargs="+", required=True)

    args = parser.parse_args()
    params = {"symbols": json.dumps(args.symbols, ensure_ascii=False)}

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""分页查询指数权重列表（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os


def safe_urlopen(req, timeout=30):
    url = req.full_url if isinstance(req, urllib.request.Request) else str(req)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req, urllib.request.Request):
        req = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        req.add_unredirected_header(key, value)
    return SAFE_URLOPENER.open(req, timeout=timeout)

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/index/index_weight"


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="分页查询指数权重列表")
    parser.add_argument(
        "--index-code",
        dest="index_code",
        required=True,
        help="指数代码，如 000300，不能为空",
    )
    parser.add_argument(
        "--date",
        default=None,
        help="查询日期，YYYYMMDD；不传则由服务端默认行为决定",
    )
    parser.add_argument(
        "--page",
        type=int,
        default=1,
        help="页码，从 1 开始，默认 1",
    )
    parser.add_argument(
        "--page-size",
        dest="page_size",
        type=int,
        default=20,
        help="每页条数，默认 20，最大 100",
    )
    args = parser.parse_args()

    index_code = args.index_code.strip()
    if not index_code:
        print("index_code 不能为空", file=sys.stderr)
        sys.exit(1)
    if args.page < 1:
        print("page 须 >= 1", file=sys.stderr)
        sys.exit(1)
    if args.page_size < 1 or args.page_size > 100:
        print("page_size 须在 1～100 之间", file=sys.stderr)
        sys.exit(1)

    params = {"index_code": index_code, "page": args.page, "page_size": args.page_size}
    if args.date is not None and str(args.date).strip() != "":
        params["date"] = args.date.strip()

    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("X-Client-Name", "ft-claw")
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"请求失败: {e.reason}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""分页查询指数权重汇总（market.ft.tech）"""
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

DEFAULT_BASE_URL = "https://market.ft.tech/gateway/"
ENDPOINT = "api/v1/market/data/index/index_weight_summary"


def base_url() -> str:
    return os.environ.get("FTSHARE_BASE_URL", DEFAULT_BASE_URL).rstrip("/") + "/"


def build_url(params: dict) -> str:
    return urllib.parse.urljoin(base_url(), ENDPOINT) + "?" + urllib.parse.urlencode(params)


def safe_urlopen(req, timeout=30):
    url = req.full_url if isinstance(req, urllib.request.Request) else str(req)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(base_url())
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req, urllib.request.Request):
        req = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        req.add_unredirected_header(key, value)
    return SAFE_URLOPENER.open(req, timeout=timeout)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="分页查询指数权重汇总")
    parser.add_argument(
        "--index-code",
        dest="index_code",
        default=None,
        help="指数代码，如 000300；不传则分页返回全部指数权重汇总",
    )
    parser.add_argument(
        "--page",
        type=int,
        default=1,
        help="页码，从 1 开始，默认 1",
    )
    parser.add_argument(
        "--page-size",
        dest="page_size",
        type=int,
        default=20,
        help="每页条数，默认 20，最大 100",
    )
    args = parser.parse_args()

    if args.page < 1:
        print("page 须 >= 1", file=sys.stderr)
        sys.exit(1)
    if args.page_size < 1 or args.page_size > 100:
        print("page_size 须在 1～100 之间", file=sys.stderr)
        sys.exit(1)

    params = {"page": args.page, "page_size": args.page_size}
    if args.index_code:
        params["index_code"] = args.index_code
    url = build_url(params)

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("X-Client-Name", "ft-claw")
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"请求失败: {e.reason}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/institution/institution-share-holdings'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='机构股本持股')
    parser.add_argument("--institution_id", required=False)
    parser.add_argument("--year", required=True)
    parser.add_argument("--report_type", required=True)
    parser.add_argument("--invest_type", required=True)
    args = parser.parse_args()
    params = {}
    if args.institution_id is not None: params["institution_id"] = args.institution_id
    if args.year is not None: params["year"] = args.year
    if args.report_type is not None: params["report_type"] = args.report_type
    if args.invest_type is not None: params["invest_type"] = args.invest_type
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/intraday-auction-volume/symbol"


def main():
    parser = argparse.ArgumentParser(description="查询单标的连续竞价成交量")
    parser.add_argument("--symbol", required=True)
    parser.add_argument("--trade-date", dest="trade_date")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)
    args = parser.parse_args()
    if args.page < 1 or not 1 <= args.page_size <= 200:
        parser.error("page 须大于等于 1，page-size 须在 1～200 之间")
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    params = {"symbol": args.symbol, "page": args.page, "page_size": args.page_size}
    if args.trade_date is not None:
        params["trade_date"] = args.trade_date
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if (parsed.scheme, parsed.netloc) != (base.scheme, base.netloc):
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    request = urllib.request.Request(
        url,
        headers={"FTSHARE_API_KEY": key, "Content-Type": "application/json"},
        method="GET",
    )
    try:
        with urllib.request.urlopen(request, timeout=30) as response:
            result = json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v3/market/data/kline-pattern-annotations'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='K线形态标注')
    parser.add_argument("--date")
    parser.add_argument("--symbol")
    parser.add_argument("--pattern")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    args = parser.parse_args()
    params = {}
    if args.date is not None: params["date"] = args.date
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.pattern is not None: params["pattern"] = args.pattern
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/libor-daily'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='国际基准利率日度')
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--currency")
    parser.add_argument("--tenor")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--trade_date", required=True)
    parser.add_argument("--rate", required=False)
    args = parser.parse_args()
    params = {}
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.currency is not None: params["currency"] = args.currency
    if args.tenor is not None: params["tenor"] = args.tenor
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.currency is not None: params["currency"] = args.currency
    if args.tenor is not None: params["tenor"] = args.tenor
    if args.rate is not None: params["rate"] = args.rate
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/limit-event-timeline-3s'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='涨跌停事件时间线')
    parser.add_argument("--symbol")
    parser.add_argument("--trade_date")
    parser.add_argument("--ready", required=False)
    parser.add_argument("--status", required=False)
    parser.add_argument("--limit_up_price", required=False)
    parser.add_argument("--limit_down_price", required=False)
    parser.add_argument("--limit_up_enter", required=False)
    parser.add_argument("--limit_up_break", required=False)
    parser.add_argument("--limit_down_enter", required=True)
    parser.add_argument("--limit_down_break", required=True)
    parser.add_argument("--first_limit_up_time", required=False)
    parser.add_argument("--limit_up_break_count", required=False)
    parser.add_argument("--last_limit_down_time", required=False)
    parser.add_argument("--limit_down_break_count", required=False)
    parser.add_argument("--limit_down_seal_value", required=False)
    args = parser.parse_args()
    params = {}
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.symbol is not None: params["symbol"] = args.symbol
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.ready is not None: params["ready"] = args.ready
    if args.status is not None: params["status"] = args.status
    if args.limit_up_price is not None: params["limit_up_price"] = args.limit_up_price
    if args.limit_down_price is not None: params["limit_down_price"] = args.limit_down_price
    if args.limit_up_enter is not None: params["limit_up_enter"] = args.limit_up_enter
    if args.limit_up_break is not None: params["limit_up_break"] = args.limit_up_break
    if args.limit_down_enter is not None: params["limit_down_enter"] = args.limit_down_enter
    if args.limit_down_break is not None: params["limit_down_break"] = args.limit_down_break
    if args.first_limit_up_time is not None: params["first_limit_up_time"] = args.first_limit_up_time
    if args.limit_up_break_count is not None: params["limit_up_break_count"] = args.limit_up_break_count
    if args.last_limit_down_time is not None: params["last_limit_down_time"] = args.last_limit_down_time
    if args.limit_down_break_count is not None: params["limit_down_break_count"] = args.limit_down_break_count
    if args.limit_down_seal_value is not None: params["limit_down_seal_value"] = args.limit_down_seal_value
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/limit-list'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='涨跌停池')
    parser.add_argument("--limit_type", required=True)
    parser.add_argument("--trade_date")
    args = parser.parse_args()
    params = {}
    if args.limit_type is not None: params["limit_type"] = args.limit_type
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v3/market/data/limit-up-reports/briefs'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='涨停简报')
    parser.add_argument("--date", required=True)
    args = parser.parse_args()
    params = {"date": args.date}
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v3/market/data/limit-up-reports/public-report'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='涨停对外归因报告')
    parser.add_argument("--date", required=True)
    parser.add_argument("--security_code", required=False)
    args = parser.parse_args()
    params = {"date": args.date, "security_code": args.security_code}
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""按公告日期范围查询 A 股重大合同（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="按公告日期范围查询重大合同")
    parser.add_argument("--start_date", required=True, help="开始日期，格式 YYYYMMDD")
    parser.add_argument("--end_date", required=True, help="结束日期，格式 YYYYMMDD")
    args = parser.parse_args()

    params = {
        "start_date": args.start_date,
        "end_date": args.end_date,
    }
    path = "/api/v1/market/data/corporate/contract?" + urllib.parse.urlencode(params)
    url = BASE_URL + path

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""按股票代码查询重大合同历史（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="按股票代码查询重大合同")
    parser.add_argument("--symbol", required=True, help="股票代码（6 位），如 300500")
    parser.add_argument("--page", type=int, default=None, help="页码，从 1 开始")
    parser.add_argument("--page_size", type=int, default=None, help="每页数量，默认 50，最大 200")
    args = parser.parse_args()

    params = {"symbol": args.symbol}
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size

    path = "/api/v1/market/data/corporate/contract/by-symbol?" + urllib.parse.urlencode(params)
    url = BASE_URL + path

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""近一年 A 股个股重大合同汇总排名（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="近一年个股重大合同汇总排名")
    parser.add_argument("--page", type=int, default=None, help="页码，从 1 开始")
    parser.add_argument("--page_size", type=int, default=None, help="每页数量，默认 50，最大 200")
    args = parser.parse_args()

    params = {}
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size

    path = "/api/v1/market/data/corporate/contract/summary"
    if params:
        path += "?" + urllib.parse.urlencode(params)
    url = BASE_URL + path

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""获取 A 股融资融券明细，支持单日/区间查询、分页与全量拉取"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/margin-trading-details"


def _check_date(value, flag):
    if len(value) != 8 or not value.isdigit():
        print(f"{flag} 格式应为 YYYYMMDD：{value}", file=sys.stderr)
        raise SystemExit(2)
    return value


def build_params(page, page_size, date, start_date, end_date, stock):
    if page < 1:
        print("--page 必须大于等于 1", file=sys.stderr)
        raise SystemExit(2)
    if page_size < 1 or page_size > 1000:
        print("--page_size 允许范围 1~1000", file=sys.stderr)
        raise SystemExit(2)
    params = {"page": page, "page_size": page_size}
    if date:
        params["date"] = _check_date(date, "--date")
    if start_date or end_date:
        if date:
            print("--date 不能与 --start-date/--end-date 同时使用", file=sys.stderr)
            raise SystemExit(2)
        if not (start_date and end_date and stock):
            print("区间查询需要 --start-date、--end-date、--stock 同时提供", file=sys.stderr)
            raise SystemExit(2)
        _check_date(start_date, "--start-date")
        _check_date(end_date, "--end-date")
        if start_date >= end_date:
            print("--start-date 必须早于 --end-date", file=sys.stderr)
            raise SystemExit(2)
        end_ymd = (int(end_date[:4]), int(end_date[4:6]), int(end_date[6:8]))
        start_limit = (int(start_date[:4]) + 3, int(start_date[4:6]), int(start_date[6:8]))
        if end_ymd > start_limit:
            print("区间跨度不能超过 3 年", file=sys.stderr)
            raise SystemExit(2)
        params["start_date"] = start_date
        params["end_date"] = end_date
        params["stock"] = stock
    elif stock:
        params["stock"] = stock
    return params


def fetch_page(params: dict) -> dict:
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="获取 A 股融资融券明细")
    parser.add_argument("--page", type=int, default=1, help="页码（从 1 开始）")
    parser.add_argument("--page_size", type=int, default=20, help="每页记录数（最大 1000）")
    parser.add_argument("--date", type=str, default=None,
                        help="单日查询日期，格式 YYYYMMDD，必须为交易日；不传返回前一交易日快照")
    parser.add_argument("--start-date", dest="start_date", type=str, default=None,
                        help="区间查询开始日期 YYYYMMDD；须与 --end-date、--stock 同时提供")
    parser.add_argument("--end-date", dest="end_date", type=str, default=None,
                        help="区间查询结束日期 YYYYMMDD；须与 --start-date、--stock 同时提供，跨度不超过 3 年")
    parser.add_argument("--stock", type=str, default=None,
                        help="标的代码过滤，如 600000.SH；区间查询时必填")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量数据")
    args = parser.parse_args()

    params = build_params(args.page, args.page_size, args.date,
                          args.start_date, args.end_date, args.stock)

    if args.fetch_all:
        first = fetch_page(params)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        pages = data.get("pages", 1)
        for p in range(2, pages + 1):
            page_params = dict(params, page=p)
            page_data = fetch_page(page_params)
            records.extend((page_data.get("data") or {}).get("records", []))
        result = {"records": records, "pages": pages, "total": data.get("total", len(records))}
    else:
        result = fetch_page(params)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for margin-trading-details handler"""
import json
import os
import sys
import unittest
import urllib.error
from io import BytesIO, StringIO
from unittest.mock import patch

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import importlib.util
spec = importlib.util.spec_from_file_location("handler", os.path.join(os.path.dirname(os.path.abspath(__file__)), "handler.py"))
handler = importlib.util.module_from_spec(spec)

ENVELOPE = b'{"code":200,"message":"success","data":{"pageNum":1,"pageSize":2,"total":16,"pages":8,"records":[{"symbol":"600000.SH"}]}}'


class TestBuildParams(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_default_params(self):
        params = handler.build_params(1, 20, None, None, None, None)
        self.assertEqual(params, {"page": 1, "page_size": 20})

    def test_date_query(self):
        params = handler.build_params(1, 20, "20260623", None, None, None)
        self.assertEqual(params["date"], "20260623")

    def test_date_with_stock(self):
        params = handler.build_params(1, 20, "20260623", None, None, "600000.SH")
        self.assertEqual(params["date"], "20260623")
        self.assertEqual(params["stock"], "600000.SH")

    def test_range_query(self):
        params = handler.build_params(1, 20, None, "20260601", "20260623", "600000.SH")
        self.assertEqual(params["start_date"], "20260601")
        self.assertEqual(params["end_date"], "20260623")
        self.assertEqual(params["stock"], "600000.SH")
        self.assertNotIn("date", params)

    def test_rejects_date_with_range(self):
        with self.assertRaises(SystemExit):
            handler.build_params(1, 20, "20260623", "20260601", "20260623", "600000.SH")

    def test_rejects_incomplete_range(self):
        with self.assertRaises(SystemExit):
            handler.build_params(1, 20, None, "20260601", None, None)
        with self.assertRaises(SystemExit):
            handler.build_params(1, 20, None, "20260601", "20260623", None)

    def test_rejects_start_after_end(self):
        with self.assertRaises(SystemExit):
            handler.build_params(1, 20, None, "20260623", "20260601", "600000.SH")

    def test_rejects_span_over_three_years(self):
        with self.assertRaises(SystemExit):
            handler.build_params(1, 20, None, "20200101", "20260623", "600000.SH")

    def test_allows_exactly_three_years(self):
        params = handler.build_params(1, 20, None, "20230623", "20260623", "600000.SH")
        self.assertEqual(params["start_date"], "20230623")

    def test_rejects_bad_date_format(self):
        with self.assertRaises(SystemExit):
            handler.build_params(1, 20, "2026-06-23", None, None, None)

    def test_rejects_page_size_out_of_range(self):
        with self.assertRaises(SystemExit):
            handler.build_params(1, 1001, None, None, None, None)


class TestFetchPage(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_url_contains_params(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = ENVELOPE
        handler.fetch_page({"page": 2, "page_size": 200, "date": "20260623"})
        called_url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/margin-trading-details", called_url)
        self.assertIn("page=2", called_url)
        self.assertIn("page_size=200", called_url)
        self.assertIn("date=20260623", called_url)

    @patch.object(handler, "safe_urlopen")
    def test_returns_parsed_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = ENVELOPE
        result = handler.fetch_page({"page": 1, "page_size": 2})
        self.assertEqual(result["data"]["records"][0]["symbol"], "600000.SH")
        self.assertEqual(result["data"]["pages"], 8)

    @patch.object(handler, "safe_urlopen")
    def test_http_error_exits(self, mock_open):
        mock_open.side_effect = urllib.error.HTTPError(
            "http://fake", 500, "Internal Error", {}, BytesIO(b"server error")
        )
        with self.assertRaises(SystemExit):
            handler.fetch_page({"page": 1, "page_size": 20})


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_single_page(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = ENVELOPE
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--page", "1", "--page_size", "2"]):
                with patch("sys.stdout", new_callable=StringIO) as fake_out:
                    handler.main()
                    result = json.loads(fake_out.getvalue())
                    self.assertEqual(result["code"], 200)
                    self.assertEqual(result["data"]["total"], 16)

    @patch.object(handler, "safe_urlopen")
    def test_range_query_flags(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = ENVELOPE
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--start-date", "20260601",
                                            "--end-date", "20260623", "--stock", "600000.SH"]):
                handler.main()
        called_url = mock_open.call_args[0][0]
        self.assertIn("start_date=20260601", called_url)
        self.assertIn("end_date=20260623", called_url)
        self.assertIn("stock=600000.SH", called_url)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_all_pagination(self, mock_open):
        page1 = b'{"data":{"records":[{"symbol":"A"},{"symbol":"B"}],"pages":2,"total":3}}'
        page2 = b'{"data":{"records":[{"symbol":"C"}],"pages":2,"total":3}}'
        mock_open.return_value.__enter__.return_value.read.side_effect = [page1, page2]

        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--page_size", "2", "--all"]):
                with patch("sys.stdout", new_callable=StringIO) as fake_out:
                    handler.main()
                    result = json.loads(fake_out.getvalue())
                    self.assertEqual(len(result["records"]), 3)
                    self.assertEqual(result["pages"], 2)
                    self.assertEqual(result["total"], 3)

    def test_main_rejects_incomplete_range(self):
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
            with patch.object(sys, "argv", ["handler.py", "--start-date", "20260601"]):
                with self.assertRaises(SystemExit):
                    handler.main()


class TestSafeUrlopen(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_rejects_non_https(self):
        with self.assertRaises(SystemExit):
            handler.safe_urlopen("http://market.ft.tech/api")

    def test_rejects_wrong_host(self):
        with self.assertRaises(SystemExit):
            handler.safe_urlopen("https://evil.com/api")


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/market-distribution-intraday'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='市场涨跌分布分时')
    parser.add_argument("--ts_millis", required=True)
    parser.add_argument("--up_limited", required=True)
    parser.add_argument("--down_limited", required=True)
    args = parser.parse_args()
    params = {}
    if args.ts_millis is not None: params["ts_millis"] = args.ts_millis
    if args.up_limited is not None: params["up_limited"] = args.up_limited
    if args.down_limited is not None: params["down_limited"] = args.down_limited
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""分页查询单个期货会员在指定合约/日期区间的持仓变化，并结合合约行情估算每日及累计盈亏"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/member-build-process"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def fetch_page(page: int, page_size: int, **extra) -> dict:
    params = {"page": page, "page_size": page_size}
    params.update({k: v for k, v in extra.items() if v is not None})
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="查询期货会员建仓过程")
    parser.add_argument("--exchange", required=True, help="交易所代码，如 SHFE/DCE/CZCE")
    parser.add_argument("--member_name", required=True, help="会员名称，如 永安期货")
    parser.add_argument("--instrument_id", required=True, help="合约代码，如 rb2601")
    parser.add_argument("--start_date", default=None, help="起始日期 YYYYMMDD 或 YYYY-MM-DD，默认 20260101")
    parser.add_argument("--end_date", default=None, help="结束日期 YYYYMMDD 或 YYYY-MM-DD，默认当天")
    parser.add_argument("--contract_multiplier", type=float, default=None,
                        help="合约乘数；不传时按品种默认表推导")
    parser.add_argument("--page", type=int, default=1, help="页码（默认 1）")
    parser.add_argument("--page_size", type=int, default=50, help="每页条数（默认 50，最大 200）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量")
    args = parser.parse_args()

    extra = dict(exchange=args.exchange, member_name=args.member_name, instrument_id=args.instrument_id,
                 start_date=args.start_date, end_date=args.end_date,
                 contract_multiplier=args.contract_multiplier)

    if args.fetch_all:
        first = fetch_page(1, args.page_size, **extra)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        pages = data.get("pages", 1)
        for p in range(2, pages + 1):
            d = fetch_page(p, args.page_size, **extra).get("data") or {}
            records.extend(d.get("records", []))
        result = {
            "code": first.get("code"), "message": first.get("message"),
            "data": {"pageNum": 1, "pageSize": args.page_size,
                     "total": data.get("total", len(records)), "pages": pages, "records": records},
        }
    else:
        result = fetch_page(args.page, args.page_size, **extra)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""分页查询指定交易日/交易所/合约/方向的期货会员持仓排名"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/member-position-ranking"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def fetch_page(page: int, page_size: int, **extra) -> dict:
    params = {"page": page, "page_size": page_size}
    params.update({k: v for k, v in extra.items() if v is not None})
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="查询期货会员持仓排名")
    parser.add_argument("--exchange", required=True, help="交易所代码，如 SHFE/DCE/CZCE")
    parser.add_argument("--instrument_id", required=True, help="合约代码，如 a2605")
    parser.add_argument("--trade_date", required=True, help="交易日 YYYYMMDD 或 YYYY-MM-DD")
    parser.add_argument("--direction", required=True, help="查询方向：long 或 short（也接受常见中文和缩写别名）")
    parser.add_argument("--page", type=int, default=1, help="页码（默认 1）")
    parser.add_argument("--page_size", type=int, default=50, help="每页条数（默认 50，最大 200）")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量")
    args = parser.parse_args()

    extra = dict(exchange=args.exchange, instrument_id=args.instrument_id,
                 trade_date=args.trade_date, direction=args.direction)

    if args.fetch_all:
        first = fetch_page(1, args.page_size, **extra)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        pages = data.get("pages", 1)
        for p in range(2, pages + 1):
            d = fetch_page(p, args.page_size, **extra).get("data") or {}
            records.extend(d.get("records", []))
        result = {
            "code": first.get("code"), "message": first.get("message"),
            "data": {"pageNum": 1, "pageSize": args.page_size,
                     "total": data.get("total", len(records)), "pages": pages, "records": records},
        }
    else:
        result = fetch_page(args.page, args.page_size, **extra)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询 A 股股票曾用名（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


ENDPOINT = "/api/v1/market/data/namechange"


def build_params(trade_code, start_date, end_date):
    params = {}
    if trade_code:
        params["trade_code"] = trade_code
    if start_date:
        params["start_date"] = start_date
    if end_date:
        params["end_date"] = end_date
    return params


def fetch(
trade_code, start_date, end_date):
    params = urllib.parse.urlencode(build_params(trade_code, start_date, end_date))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询 A 股股票曾用名")
    parser.add_argument(
        "--trade_code",
        required=True,
        help="股票代码（带 .SZ/.SH 后缀），支持逗号分隔多个，如 600848.SH",
    )
    parser.add_argument("--start_date", help="过滤区间起始日期，YYYYMMDD 格式")
    parser.add_argument("--end_date", help="过滤区间结束日期，YYYYMMDD 格式")
    args = parser.parse_args()

    result = fetch(args.trade_code, args.start_date, args.end_date)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for namechange handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_by_trade_code(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", None, None)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/namechange", url)
        self.assertIn("trade_code=600848.SH", url)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_with_date_range(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", "20200101", "20241231")
        url = mock_open.call_args[0][0]
        self.assertIn("start_date=20200101", url)
        self.assertIn("end_date=20241231", url)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.object(sys, "argv", ["handler.py", "--trade_code", "600848.SH"]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

    def test_main_requires_trade_code(self):
        with patch.object(sys, "argv", ["handler.py"]):
            with self.assertRaises(SystemExit):
                handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/futures/nanhua-index-kline'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='南华期货指数日K线')
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    args = parser.parse_args()
    params = {}
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v3/market/data/news-reaction-snapshot"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"Content-Type": "application/json", "X-Client-Name": "ft-claw"}
LOOKBACK_HOURS = (24, 48)


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def fetch(params):
    url = BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params)
    request = urllib.request.Request(url, headers=_REQUEST_HEADERS, method="GET")
    try:
        with safe_urlopen(request) as response:
            return json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="消息量价共振")
    parser.add_argument("--symbol", required=True, help="股票代码，带交易所后缀，如 600519.SH")
    parser.add_argument("--start-date", dest="start_date", required=True, help="起始交易日（含）")
    parser.add_argument("--end-date", dest="end_date", required=True, help="截止交易日（含），跨度不超过 31 天")
    parser.add_argument("--lookback-hours", dest="lookback_hours", type=int, choices=LOOKBACK_HOURS,
                        help="新闻回看窗口（小时），仅 24 或 48；不传返回两套窗口")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始，默认 1，最大 1000")
    parser.add_argument("--page-size", dest="page_size", type=int, default=50, help="每页条数，默认 50，最大 200")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页返回全部记录")
    args = parser.parse_args()
    if not 1 <= args.page <= 1000 or not 1 <= args.page_size <= 200:
        parser.error("page 须在 1～1000 之间，page-size 须在 1～200 之间")

    base = {"symbol": args.symbol, "start_date": args.start_date, "end_date": args.end_date}
    if args.lookback_hours is not None:
        base["lookback_hours"] = args.lookback_hours

    result = fetch({**base, "page": 1 if args.fetch_all else args.page, "page_size": args.page_size})
    if args.fetch_all:
        data = result.get("data") or {}
        records = list(data.get("records", []))
        for page in range(2, int(data.get("pages", 1)) + 1):
            records.extend((fetch({**base, "page": page, "page_size": args.page_size}).get("data") or {}).get("records", []))
        result["data"] = {**data, "records": records}
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for news-reaction-snapshot handler."""
import importlib.util
import json
import os
import sys
import unittest
from unittest.mock import patch

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


def _run(argv):
    with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}):
        with patch.object(sys, "argv", ["handler.py"] + argv):
            handler.main()


class TestNewsReactionSnapshot(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_forwards_required_and_optional_params(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--symbol", "600519.SH", "--start-date", "20260818", "--end-date", "20260828",
              "--lookback-hours", "48", "--page", "2", "--page-size", "5"])
        req = mock_open.call_args[0][0]
        self.assertIn("/api/v3/market/data/news-reaction-snapshot", req.full_url)
        self.assertIn("symbol=600519.SH", req.full_url)
        self.assertIn("start_date=20260818", req.full_url)
        self.assertIn("end_date=20260828", req.full_url)
        self.assertIn("lookback_hours=48", req.full_url)
        self.assertIn("page=2", req.full_url)
        self.assertIn("page_size=5", req.full_url)

    @patch.object(handler, "safe_urlopen")
    def test_lookback_hours_omitted_when_absent(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"{}"
        _run(["--symbol", "600519.SH", "--start-date", "20260818", "--end-date", "20260828"])
        req = mock_open.call_args[0][0]
        self.assertNotIn("lookback_hours", req.full_url)

    def test_rejects_invalid_lookback_hours(self):
        with self.assertRaises(SystemExit):
            _run(["--symbol", "600519.SH", "--start-date", "20260818", "--end-date", "20260828",
                  "--lookback-hours", "12"])

    def test_rejects_out_of_range_pagination(self):
        with self.assertRaises(SystemExit):
            _run(["--symbol", "600519.SH", "--start-date", "20260818", "--end-date", "20260828",
                  "--page-size", "201"])

    def test_fetch_all_aggregates_records(self):
        pages = {
            1: {"data": {"pages": 2, "records": [{"trade_date": "20260819"}]}},
            2: {"data": {"pages": 2, "records": [{"trade_date": "20260820"}]}},
        }
        captured = []

        def fake_fetch(params):
            captured.append(params["page"])
            return pages[params["page"]]

        with patch.object(handler, "fetch", side_effect=fake_fetch):
            with patch("builtins.print") as mock_print:
                _run(["--symbol", "600519.SH", "--start-date", "20260818", "--end-date", "20260828", "--all"])
        self.assertEqual(captured, [1, 2])
        output = json.loads(mock_print.call_args[0][0])
        self.assertEqual([row["trade_date"] for row in output["data"]["records"]], ["20260819", "20260820"])


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询北向资金（沪股通、深股通）交易汇总数据"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/northbound"


def fetch(
date: str) -> dict:
    params = urllib.parse.urlencode({"date": date})
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询北向资金交易数据")
    parser.add_argument("--date", required=True, help="交易日期，格式 YYYYMMDD")
    args = parser.parse_args()

    result = fetch(args.date)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL=os.environ.get("FTSHARE_BASE_URL","https://market.ft.tech/gateway").rstrip("/"); ENDPOINT="/api/v1/market/data/time/get-nth-trade-date"
_REQUEST_HEADERS={"Content-Type":"application/json"}
def safe_urlopen(request):
 url=request.full_url if isinstance(request,urllib.request.Request) else str(request)
 parsed=urllib.parse.urlparse(url); base=urllib.parse.urlparse(BASE_URL)
 if (parsed.scheme,parsed.netloc)!=(base.scheme,base.netloc): print("Invalid URL for safe_urlopen",file=sys.stderr); raise SystemExit(1)
 if not isinstance(request,urllib.request.Request): request=urllib.request.Request(url,headers=_REQUEST_HEADERS,method="GET")
 return urllib.request.urlopen(request,timeout=30)
def main():
 p=argparse.ArgumentParser(description="查询第 N 个交易日"); p.add_argument("--n",type=int,required=True); a=p.parse_args()
 if a.n<1: p.error("n 必须大于等于 1")
 key=os.environ.get("FTSHARE_API_KEY")
 if not key: print("FTSHARE_API_KEY environment variable is required",file=sys.stderr); raise SystemExit(2)
 url=BASE_URL+ENDPOINT+"?"+urllib.parse.urlencode({"n":a.n}); b,purl=urllib.parse.urlparse(BASE_URL),urllib.parse.urlparse(url)
 if (b.scheme,b.netloc)!=(purl.scheme,purl.netloc): print("Invalid URL for safe_urlopen",file=sys.stderr); raise SystemExit(1)
 try:
  req=urllib.request.Request(url,headers={"FTSHARE_API_KEY":key,"Content-Type":"application/json"},method="GET")
  with safe_urlopen(req) as r: result=json.loads(r.read().decode())
 except urllib.error.HTTPError as e: print(f"HTTP {e.code}: {e.read().decode()}",file=sys.stderr); raise SystemExit(1)
 except urllib.error.URLError as e: print(f"请求失败: {e.reason}",file=sys.stderr); raise SystemExit(1)
 print(json.dumps(result,ensure_ascii=False,indent=2))
if __name__=="__main__":main()

import importlib.util
import json
import os
import sys
import unittest
from io import StringIO
from unittest.mock import patch

_DIR = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_DIR, "handler.py"))
handler = importlib.util.module_from_spec(spec)
spec.loader.exec_module(handler)

class TestHandler(unittest.TestCase):
    @patch.object(handler, "safe_urlopen")
    def test_n_is_encoded_and_json_emitted(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b'{"code": 200, "data": {"n": 5}}'
        with patch.dict(os.environ, {"FTSHARE_API_KEY": "test-key"}), patch.object(sys, "argv", ["handler.py", "--n", "5"]), patch("sys.stdout", new_callable=StringIO) as out:
            handler.main()
        request = mock_open.call_args.args[0]
        self.assertIn("n=5", request.full_url)
        self.assertEqual(json.loads(out.getvalue())["data"]["n"], 5)

if __name__ == "__main__": unittest.main()

#!/usr/bin/env python3
"""查询单只 A 股股票所有报告期的股权质押详细信息"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/pledge/pledge-detail"


def fetch(
stock_code: str, page: int, page_size: int) -> dict:
    params = urllib.parse.urlencode({
        "stock_code": stock_code,
        "page": page,
        "page_size": page_size,
    })
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只 A 股股票所有报告期的股权质押详细信息")
    parser.add_argument(
        "--stock_code",
        required=True,
        help="股票代码，需携带市场后缀，如 603323.SH / 000001.SZ / 833171.BJ",
    )
    parser.add_argument(
        "--page",
        type=int,
        default=1,
        help="页码，从 1 开始，默认 1",
    )
    parser.add_argument(
        "--page_size",
        type=int,
        default=50,
        help="每页记录数，默认 50",
    )
    args = parser.parse_args()

    result = fetch(args.stock_code, args.page, args.page_size)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询 A 股市场股权质押汇总。"""
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/pledge/pledge-summary"


def safe_urlopen(req_or_url):
    url = req_or_url.full_url if isinstance(req_or_url, urllib.request.Request) else str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询 A 股市场股权质押汇总")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始")
    parser.add_argument("--page-size", dest="page_size", type=int, default=50, help="每页条数，最大 200")
    args = parser.parse_args()

    query = urllib.parse.urlencode({"page": args.page, "page_size": args.page_size})
    request = urllib.request.Request(f"{BASE_URL}{ENDPOINT}?{query}", method="GET", headers=_REQUEST_HEADERS)
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        body = error.read().decode().strip()
        message = f"HTTP {error.code}"
        if body:
            message += f": {body}"
        print(message, file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        sys.exit(1)

    data = payload.get("data") if isinstance(payload, dict) else None
    records = data.get("records") if isinstance(data, dict) else None
    if not isinstance(records, list):
        print(json.dumps({"error": "unexpected response shape"}, ensure_ascii=False), file=sys.stderr)
        sys.exit(1)
    print(json.dumps(payload, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

from __future__ import annotations

import importlib.util
import json
import sys
from pathlib import Path
from urllib.parse import parse_qs, urlparse

import pytest


HANDLER = Path(__file__).with_name("handler.py")


def load_handler():
    spec = importlib.util.spec_from_file_location("pledge_summary_handler", HANDLER)
    module = importlib.util.module_from_spec(spec)
    assert spec.loader is not None
    spec.loader.exec_module(module)
    return module


class Response:
    def __init__(self, payload):
        self.payload = payload

    def __enter__(self):
        return self

    def __exit__(self, *args):
        return None

    def read(self):
        return json.dumps(self.payload).encode()


def test_main_preserves_paginated_envelope(monkeypatch, capsys):
    module = load_handler()
    opened = []
    payload = {
        "code": 0,
        "message": "success",
        "data": {"pageNum": 1, "pageSize": 5, "total": 1, "pages": 1, "records": [{"trade_date": "2026-07-17", "pledge_total_ratio": "0.1250"}]},
    }
    monkeypatch.setattr(sys, "argv", ["handler.py", "--page", "1", "--page-size", "5"])
    monkeypatch.setattr(module, "safe_urlopen", lambda request: opened.append(request) or Response(payload))

    module.main()

    parsed = urlparse(opened[0].full_url)
    assert parsed.path == "/gateway/api/v1/market/data/pledge/pledge-summary"
    assert parse_qs(parsed.query) == {"page": ["1"], "page_size": ["5"]}
    assert json.loads(capsys.readouterr().out) == payload


def test_main_accepts_empty_records(monkeypatch, capsys):
    module = load_handler()
    payload = {"code": 0, "message": "success", "data": {"records": []}}
    monkeypatch.setattr(sys, "argv", ["handler.py"])
    monkeypatch.setattr(module, "safe_urlopen", lambda request: Response(payload))

    module.main()

    assert json.loads(capsys.readouterr().out) == payload


def test_main_rejects_unexpected_response_shape(monkeypatch, capsys):
    module = load_handler()
    monkeypatch.setattr(sys, "argv", ["handler.py"])
    monkeypatch.setattr(module, "safe_urlopen", lambda request: Response(["unexpected"]))

    with pytest.raises(SystemExit):
        module.main()

    assert json.loads(capsys.readouterr().err) == {"error": "unexpected response shape"}

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/price/get-price-change'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='价格变动')
    parser.add_argument("--stock_code", required=True)
    parser.add_argument("--base_date", required=True)
    parser.add_argument("--n", required=True)
    parser.add_argument("--direction", required=True)
    parser.add_argument("--stock_name", required=True)
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--actual_trading_days", required=True)
    parser.add_argument("--start_price", required=True)
    parser.add_argument("--end_price", required=True)
    parser.add_argument("--price_change", required=True)
    parser.add_argument("--change_pct", required=False)
    args = parser.parse_args()
    params = {}
    if args.stock_code is not None: params["stock_code"] = args.stock_code
    if args.base_date is not None: params["base_date"] = args.base_date
    if args.n is not None: params["n"] = args.n
    if args.direction is not None: params["direction"] = args.direction
    if args.stock_name is not None: params["stock_name"] = args.stock_name
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.actual_trading_days is not None: params["actual_trading_days"] = args.actual_trading_days
    if args.start_price is not None: params["start_price"] = args.start_price
    if args.end_price is not None: params["end_price"] = args.end_price
    if args.price_change is not None: params["price_change"] = args.price_change
    if args.change_pct is not None: params["change_pct"] = args.change_pct
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""分页查询报告公告列表，可选按证券代码过滤；公告 ID 可用于查询公告摘要"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/report-announcements/list"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def fetch_page(page: int, page_size: int, **extra) -> dict:
    params = {"page": page, "page_size": page_size}
    params.update({k: v for k, v in extra.items() if v is not None})
    qs = urllib.parse.urlencode(params)
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description="查询报告公告列表")
    parser.add_argument("--date", required=True, help="公告日期 YYYYMMDD 或 YYYY-MM-DD")
    parser.add_argument("--sec_code", default=None, help="证券代码；不传返回当天全部证券公告")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始，默认 1")
    parser.add_argument("--page_size", type=int, default=50, help="每页数量，默认 50，最大 200")
    parser.add_argument("--all", action="store_true", dest="fetch_all", help="自动翻页获取全量")
    args = parser.parse_args()

    extra = dict(date=args.date, sec_code=args.sec_code)

    if args.fetch_all:
        first = fetch_page(1, args.page_size, **extra)
        data = first.get("data") or {}
        records = list(data.get("records", []))
        pages = data.get("pages", 1)
        for p in range(2, pages + 1):
            d = fetch_page(p, args.page_size, **extra).get("data") or {}
            records.extend(d.get("records", []))
        result = {
            "code": first.get("code"), "message": first.get("message"),
            "data": {"pageNum": 1, "pageSize": args.page_size,
                     "total": data.get("total", len(records)), "pages": pages, "records": records},
        }
    else:
        result = fetch_page(args.page, args.page_size, **extra)

    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""根据公告 ID 查询单条报告公告的摘要、标题、证券信息和处理状态"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/report-announcements/summary"


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    return SAFE_URLOPENER.open(req_or_url)


def main():
    parser = argparse.ArgumentParser(description="查询报告公告摘要")
    parser.add_argument("--announcement_id", required=True, help="公告 ID，由「报告公告列表」接口返回")
    args = parser.parse_args()

    qs = urllib.parse.urlencode({"announcement_id": args.announcement_id})
    url = f"{BASE_URL}{ENDPOINT}?{qs}"
    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v1/market/data/risk-warning-stocks"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {
    "FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"],
    "Content-Type": "application/json",
} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    for key, value in _REQUEST_HEADERS.items():
        request.add_unredirected_header(key, value)
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询风险警示股")
    parser.add_argument("--date", required=True, help="交易日，格式 YYYYMMDD")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)
    args = parser.parse_args()

    params = {"date": args.date, "page": args.page, "page_size": args.page_size}
    request = urllib.request.Request(
        BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params),
        headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw"},
        method="GET",
    )
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/security/search/'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='搜索股票标的')
    parser.add_argument("--query", required=True)
    parser.add_argument("--limit", type=int, default=1)

    args = parser.parse_args()
    params = {}
    if args.query is not None:
        params['query'] = args.query
    if args.limit is not None:
        params['limit'] = args.limit

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""语义搜索新闻（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime, timedelta, timezone
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
BEIJING_TZ = timezone(timedelta(hours=8))


def _normalize_to_beijing_iso(value: str) -> str:
    """
    将输入时间规范为东八区 ISO 8601 字符串。
    - 无时区：按东八区解释
    - 有时区：统一转换到东八区
    """
    raw = value.strip()
    if not raw:
        return raw
    if raw.endswith("Z"):
        raw = raw[:-1] + "+00:00"
    dt = datetime.fromisoformat(raw)
    if dt.tzinfo is None:
        dt = dt.replace(tzinfo=BEIJING_TZ)
    else:
        dt = dt.astimezone(BEIJING_TZ)
    return dt.isoformat()

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)



def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="语义搜索新闻")
    parser.add_argument(
        "--query",
        required=True,
        help="搜索文字，如：人工智能",
    )
    parser.add_argument(
        "--limit",
        type=int,
        default=10,
        help="返回条数，默认 10",
    )
    parser.add_argument(
        "--year",
        type=int,
        default=None,
        help="年份，仅支持当年，用于限定搜索范围；不传则由服务端决定",
    )
    parser.add_argument(
        "--start_time",
        default=None,
        help="开始时间（含），ISO 8601，如 2026-03-01T00:00:00+08:00",
    )
    parser.add_argument(
        "--end_time",
        default=None,
        help="结束时间（含），ISO 8601，如 2026-03-15T23:59:59+08:00",
    )
    args = parser.parse_args()

    params = {"query": args.query, "limit": args.limit}
    if args.year is not None:
        params["year"] = args.year
    try:
        if args.start_time:
            params["start_time"] = _normalize_to_beijing_iso(args.start_time)
        if args.end_time:
            params["end_time"] = _normalize_to_beijing_iso(args.end_time)
    except ValueError as e:
        print(f"时间格式错误：{e}", file=sys.stderr)
        sys.exit(1)

    url = BASE_URL + "/api/v3/market/data/semantic-search-news?" + urllib.parse.urlencode(params)
    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询 A 股股东大会信息（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询 A 股股东大会信息")
    parser.add_argument("--page", type=int, default=None, help="页码，从 1 开始，默认 1")
    parser.add_argument("--page_size", type=int, default=None, help="每页数量，默认 50，最大 200")
    args = parser.parse_args()

    params = {}
    if args.page is not None:
        params["page"] = args.page
    if args.page_size is not None:
        params["page_size"] = args.page_size

    path = "/api/v1/market/data/corporate/meeting"
    if params:
        path += "?" + urllib.parse.urlencode(params)
    url = BASE_URL + path

    req = urllib.request.Request(url, method="GET", headers=_REQUEST_HEADERS)
    req.add_header("Content-Type", "application/json")

    try:
        with safe_urlopen(req) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/shibor-daily'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='SHIBOR日度利率')
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--trade_date", required=True)
    parser.add_argument("--on_rate", required=False)
    parser.add_argument("--w1", required=True)
    parser.add_argument("--w2", required=True)
    parser.add_argument("--m1", required=True)
    parser.add_argument("--m3", required=True)
    parser.add_argument("--m6", required=True)
    parser.add_argument("--m9", required=True)
    parser.add_argument("--y1", required=True)
    args = parser.parse_args()
    params = {}
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.on_rate is not None: params["on_rate"] = args.on_rate
    if args.w1 is not None: params["w1"] = args.w1
    if args.w2 is not None: params["w2"] = args.w2
    if args.m1 is not None: params["m1"] = args.m1
    if args.m3 is not None: params["m3"] = args.m3
    if args.m6 is not None: params["m6"] = args.m6
    if args.m9 is not None: params["m9"] = args.m9
    if args.y1 is not None: params["y1"] = args.y1
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/shibor-quote-daily'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='SHIBOR报价日度')
    parser.add_argument("--start_date", required=True)
    parser.add_argument("--end_date", required=True)
    parser.add_argument("--bank")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--trade_date", required=True)
    parser.add_argument("--bank_en", required=True)
    parser.add_argument("--on_rate", required=False)
    parser.add_argument("--y1", required=True)
    args = parser.parse_args()
    params = {}
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.bank is not None: params["bank"] = args.bank
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.bank is not None: params["bank"] = args.bank
    if args.bank_en is not None: params["bank_en"] = args.bank_en
    if args.on_rate is not None: params["on_rate"] = args.on_rate
    if args.y1 is not None: params["y1"] = args.y1
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询南向资金（港股通沪、港股通深）交易汇总数据"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

ENDPOINT = "/api/v1/market/data/southbound"


def fetch(
date: str) -> dict:
    params = urllib.parse.urlencode({"date": date})
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询南向资金交易数据")
    parser.add_argument("--date", required=True, help="交易日期，格式 YYYYMMDD")
    args = parser.parse_args()

    result = fetch(args.date)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/hk/stk-ah-comparison"
SAFE_URLOPENER = urllib.request.build_opener()


def require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def fetch(params):
    url = f"{BASE_URL}{ENDPOINT}?{urllib.parse.urlencode(params)}"
    request = urllib.request.Request(
        url,
        headers={"FTSHARE_API_KEY": require_api_key(), "Content-Type": "application/json"},
        method="GET",
    )
    parsed = urllib.parse.urlparse(url)
    base = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    try:
        with SAFE_URLOPENER.open(request, timeout=30) as response:
            return json.loads(response.read().decode())
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


def main():
    parser = argparse.ArgumentParser(description="查询 AH 股比价")
    parser.add_argument("--hk-code", dest="hk_code")
    parser.add_argument("--ts-code", dest="ts_code")
    parser.add_argument("--trade-date", dest="trade_date", type=int)
    parser.add_argument("--start-date", dest="start_date", type=int)
    parser.add_argument("--end-date", dest="end_date", type=int)
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)
    parser.add_argument("--all", action="store_true", dest="fetch_all")
    args = parser.parse_args()
    if args.page < 1 or args.page_size < 1 or args.page_size > 1000:
        parser.error("page 须大于等于 1，page-size 须在 1～1000 之间")
    params = {k: v for k, v in vars(args).items() if k in {
        "hk_code", "ts_code", "trade_date", "start_date", "end_date"
    } and v is not None}
    if args.fetch_all:
        first = fetch({**params, "page": 1, "page_size": args.page_size})
        data = first.get("data") or {}
        records = list(data.get("records", []))
        for page in range(2, int(data.get("pages", 1)) + 1):
            payload = fetch({**params, "page": page, "page_size": args.page_size})
            records.extend((payload.get("data") or {}).get("records", []))
        first["data"] = {**data, "records": records}
        result = first
    else:
        result = fetch({**params, "page": args.page, "page_size": args.page_size})
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/stk-alert-broker'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='交易所重点提示证券')
    parser.add_argument("--ts_code")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--name", required=True)
    parser.add_argument("--type", required=True)
    args = parser.parse_args()
    params = {}
    if args.ts_code is not None: params["ts_code"] = args.ts_code
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.ts_code is not None: params["ts_code"] = args.ts_code
    if args.name is not None: params["name"] = args.name
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.type is not None: params["type"] = args.type
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
"""查询上市公司管理层持股变动明细（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


ENDPOINT = "/api/v1/market/data/stk-manager-hold"


def build_params(trade_code, end_date):
    params = {}
    if trade_code:
        params["trade_code"] = trade_code
    if end_date:
        params["end_date"] = end_date
    return params


def fetch(
trade_code, end_date):
    params = urllib.parse.urlencode(build_params(trade_code, end_date))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询上市公司管理层持股变动明细")
    parser.add_argument(
        "--trade_code",
        required=True,
        help="股票代码（带 .SZ/.SH 后缀），支持逗号分隔多个，如 600848.SH",
    )
    parser.add_argument("--end_date", help="截止日期，精确匹配，YYYYMMDD 格式")
    args = parser.parse_args()

    result = fetch(args.trade_code, args.end_date)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for stk-manager-hold handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_by_trade_code(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", None)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/stk-manager-hold", url)
        self.assertIn("trade_code=600848.SH", url)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_with_end_date(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", "20241231")
        url = mock_open.call_args[0][0]
        self.assertIn("end_date=20241231", url)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.object(sys, "argv", ["handler.py", "--trade_code", "600848.SH"]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

    def test_main_requires_trade_code(self):
        with patch.object(sys, "argv", ["handler.py"]):
            with self.assertRaises(SystemExit):
                handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询上市公司管理层年度薪酬（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


ENDPOINT = "/api/v1/market/data/stk-manager-pay"


def build_params(trade_code, end_date):
    params = {}
    if trade_code:
        params["trade_code"] = trade_code
    if end_date:
        params["end_date"] = end_date
    return params


def fetch(
trade_code, end_date):
    params = urllib.parse.urlencode(build_params(trade_code, end_date))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询上市公司管理层年度薪酬")
    parser.add_argument(
        "--trade_code",
        required=True,
        help="股票代码（带 .SZ/.SH 后缀），支持逗号分隔多个，如 600848.SH",
    )
    parser.add_argument("--end_date", help="截止日期，精确匹配，YYYYMMDD 格式")
    args = parser.parse_args()

    result = fetch(args.trade_code, args.end_date)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for stk-manager-pay handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_by_trade_code(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", None)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/stk-manager-pay", url)
        self.assertIn("trade_code=600848.SH", url)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_with_end_date(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", "20241231")
        url = mock_open.call_args[0][0]
        self.assertIn("end_date=20241231", url)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.object(sys, "argv", ["handler.py", "--trade_code", "600848.SH"]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

    def test_main_requires_trade_code(self):
        with patch.object(sys, "argv", ["handler.py"]):
            with self.assertRaises(SystemExit):
                handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
"""查询上市公司管理层信息（market.ft.tech）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


ENDPOINT = "/api/v1/market/data/stk-managers"


def build_params(trade_code, candi_date, begin_date, end_date):
    params = {}
    if trade_code:
        params["trade_code"] = trade_code
    if candi_date:
        params["candi_date"] = candi_date
    if begin_date:
        params["begin_date"] = begin_date
    if end_date:
        params["end_date"] = end_date
    return params


def fetch(
trade_code, candi_date, begin_date, end_date):
    params = urllib.parse.urlencode(build_params(trade_code, candi_date, begin_date, end_date))
    url = f"{BASE_URL}{ENDPOINT}?{params}"
    try:
        with safe_urlopen(url) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询上市公司管理层信息")
    parser.add_argument(
        "--trade_code",
        required=True,
        help="股票代码（带 .SZ/.SH 后缀），支持逗号分隔多个，如 600848.SH",
    )
    parser.add_argument("--candi_date", help="候选日期，精确匹配，YYYYMMDD 格式")
    parser.add_argument("--begin_date", help="任职起始日过滤，YYYYMMDD 格式")
    parser.add_argument("--end_date", help="任职截止日过滤，YYYYMMDD 格式")
    args = parser.parse_args()

    result = fetch(args.trade_code, args.candi_date, args.begin_date, args.end_date)
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for stk-managers handler"""
import json
import sys
import unittest
from io import StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_by_trade_code(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", None, None, None)
        url = mock_open.call_args[0][0]
        self.assertIn("/api/v1/market/data/stk-managers", url)
        self.assertIn("trade_code=600848.SH", url)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_with_candi_date(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", "20251128", None, None)
        url = mock_open.call_args[0][0]
        self.assertIn("candi_date=20251128", url)

    @patch.object(handler, "safe_urlopen")
    def test_fetch_with_begin_end(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600848.SH", None, "20200101", "20241231")
        url = mock_open.call_args[0][0]
        self.assertIn("begin_date=20200101", url)
        self.assertIn("end_date=20241231", url)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        with patch.object(sys, "argv", ["handler.py", "--trade_code", "600848.SH"]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                self.assertEqual(json.loads(fake_out.getvalue()), [])

    def test_main_requires_trade_code(self):
        with patch.object(sys, "argv", ["handler.py"]):
            with self.assertRaises(SystemExit):
                handler.main()


if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/stk-premarket'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='盘前数据')
    parser.add_argument("--ts_code")
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--pre_close")
    parser.add_argument("--up_limit")
    parser.add_argument("--down_limit")
    parser.add_argument("--price")
    parser.add_argument("--total_mv")
    parser.add_argument("--float_mv")
    args = parser.parse_args()
    params = {}
    for name in ("ts_code", "trade_date", "start_date", "end_date", "page", "page_size"):
        value = getattr(args, name)
        if value is not None:
            params[name] = value
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/stk-shock'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='个股异常波动')
    parser.add_argument("--ts_code")
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--order_book_id", required=True)
    parser.add_argument("--date", required=True)
    parser.add_argument("--side", required=False)
    parser.add_argument("--rank", required=True)
    parser.add_argument("--agency", required=False)
    parser.add_argument("--buy_value", required=False)
    parser.add_argument("--sell_value", required=False)
    parser.add_argument("--type", required=True)
    parser.add_argument("--reason", required=False)
    args = parser.parse_args()
    params = {}
    if args.ts_code is not None: params["ts_code"] = args.ts_code
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.order_book_id is not None: params["order_book_id"] = args.order_book_id
    if args.date is not None: params["date"] = args.date
    if args.side is not None: params["side"] = args.side
    if args.rank is not None: params["rank"] = args.rank
    if args.agency is not None: params["agency"] = args.agency
    if args.buy_value is not None: params["buy_value"] = args.buy_value
    if args.sell_value is not None: params["sell_value"] = args.sell_value
    if args.type is not None: params["type"] = args.type
    if args.reason is not None: params["reason"] = args.reason
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse, json, os, sys, urllib.error, urllib.parse, urllib.request
BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v2/market/data/stk-surv'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr); raise SystemExit(2)
    return key
def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr); raise SystemExit(1)
    if not isinstance(request, urllib.request.Request): request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    request.add_unredirected_header("Content-Type", "application/json")
    return SAFE_URLOPENER.open(request, timeout=timeout)
def main():
    key = _require_api_key(); parser = argparse.ArgumentParser(description='个股严重异常波动')
    parser.add_argument("--ts_code")
    parser.add_argument("--trade_date")
    parser.add_argument("--start_date")
    parser.add_argument("--end_date")
    parser.add_argument("--page")
    parser.add_argument("--page_size")
    parser.add_argument("--total", required=False)
    parser.add_argument("--name", required=True)
    parser.add_argument("--trade_market", required=True)
    parser.add_argument("--reason", required=False)
    parser.add_argument("--period", required=False)
    args = parser.parse_args()
    params = {}
    if args.ts_code is not None: params["ts_code"] = args.ts_code
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.start_date is not None: params["start_date"] = args.start_date
    if args.end_date is not None: params["end_date"] = args.end_date
    if args.page is not None: params["page"] = args.page
    if args.page_size is not None: params["page_size"] = args.page_size
    if args.total is not None: params["total"] = args.total
    if args.ts_code is not None: params["ts_code"] = args.ts_code
    if args.trade_date is not None: params["trade_date"] = args.trade_date
    if args.name is not None: params["name"] = args.name
    if args.trade_market is not None: params["trade_market"] = args.trade_market
    if args.reason is not None: params["reason"] = args.reason
    if args.period is not None: params["period"] = args.period
    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={**_REQUEST_HEADERS, "FTSHARE_API_KEY": key, "Content-Type": "application/json", "X-Client-Name": "ft-claw"}, method="GET")
    try:
        with safe_urlopen(request) as response: payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr); raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr); raise SystemExit(1)
if __name__ == "__main__": main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = '/api/v1/market/data/stock-adjust-factor'
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description='查询股票复权因子')
    parser.add_argument("--symbol")
    parser.add_argument("--trade-date")
    parser.add_argument("--start-date")
    parser.add_argument("--end-date")
    parser.add_argument("--page", type=int, default=1)
    parser.add_argument("--page-size", dest="page_size", type=int, default=50)

    args = parser.parse_args()
    params = {}
    if args.symbol is not None:
        params['symbol'] = args.symbol
    if args.trade_date is not None:
        params['trade_date'] = args.trade_date
    if args.start_date is not None:
        params['start_date'] = args.start_date
    if args.end_date is not None:
        params['end_date'] = args.end_date
    if args.page is not None:
        params['page'] = args.page
    if args.page_size is not None:
        params['page_size'] = args.page_size

    query = ("?" + urllib.parse.urlencode(params)) if params else ""
    request = urllib.request.Request(BASE_URL + ENDPOINT + query, headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            payload = json.loads(response.read().decode())
        print(json.dumps(payload, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
import argparse
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
ENDPOINT = "/api/v2/market/data/announcements/stock-announcements"
SAFE_URLOPENER = urllib.request.build_opener()
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}


def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


def safe_urlopen(request, timeout=30):
    url = request.full_url if isinstance(request, urllib.request.Request) else str(request)
    parsed, base = urllib.parse.urlparse(url), urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base.scheme or parsed.netloc != base.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        raise SystemExit(1)
    if not isinstance(request, urllib.request.Request):
        request = urllib.request.Request(url, method="GET")
    request.add_unredirected_header("FTSHARE_API_KEY", _require_api_key())
    return SAFE_URLOPENER.open(request, timeout=timeout)


def main():
    key = _require_api_key()
    parser = argparse.ArgumentParser(description="查询 A 股公告列表")
    parser.add_argument("--stock-code", dest="stock_code")
    parser.add_argument("--start-date", dest="start_date")
    parser.add_argument("--end-date", dest="end_date")
    parser.add_argument("--type", default="stock")
    parser.add_argument("--page", type=int, required=True)
    parser.add_argument("--page-size", dest="page_size", type=int, required=True)
    args = parser.parse_args()
    if not args.stock_code and not args.start_date:
        parser.error("stock-code 与 start-date 至少提供一个")
    if args.type != "stock":
        parser.error("type 当前只支持 stock")
    params = {"type": args.type, "page": args.page, "page_size": args.page_size}
    for name in ("stock_code", "start_date", "end_date"):
        value = getattr(args, name)
        if value is not None:
            params[name] = value
    request = urllib.request.Request(BASE_URL + ENDPOINT + "?" + urllib.parse.urlencode(params),
                                     headers={"FTSHARE_API_KEY": key, "X-Client-Name": "ft-claw", "Content-Type": "application/json"}, method="GET")
    try:
        with safe_urlopen(request) as response:
            print(json.dumps(json.loads(response.read().decode()), ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as error:
        print(f"HTTP {error.code}: {error.read().decode()}", file=sys.stderr)
        raise SystemExit(1)
    except urllib.error.URLError as error:
        print(f"请求失败: {error.reason}", file=sys.stderr)
        raise SystemExit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询指定报告期全市场资产负债表（分页）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os
SAFE_URLOPENER = urllib.request.build_opener()

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}

def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme != urllib.parse.urlparse(BASE_URL).scheme or parsed.netloc != urllib.parse.urlparse(BASE_URL).netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)

VALID_REPORT_TYPES = ["q1", "q2", "q3", "annual"]


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询指定报告期全市场资产负债表（分页）")
    parser.add_argument("--year", type=int, required=True, help="报告所属年度，如 2025")
    parser.add_argument("--report-type", required=True, choices=VALID_REPORT_TYPES,
                        help="报告期类型：q1（一季报）/ q2（半年报）/ q3（三季报）/ annual（年报）")
    parser.add_argument("--page", type=int, default=1, help="页码，从 1 开始（默认 1）")
    parser.add_argument("--page-size", type=int, default=20, help="每页记录数（默认 20）")
    args = parser.parse_args()

    params = {
        "year": args.year,
        "report_type": args.report_type,
        "page": args.page,
        "page_size": args.page_size,
    }
    url = f"{BASE_URL}/api/v1/market/data/finance/balance?" + urllib.parse.urlencode(params)

    try:
        with safe_urlopen(url) as resp:
            data = json.loads(resp.read().decode())
        print(json.dumps(data, ensure_ascii=False, indent=2))
    except urllib.error.HTTPError as e:
        body = e.read().decode()
        print(f"HTTP {e.code}: {body}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""查询单只标的 K 线（GET /api/v1/market/data/stock-candlesticks）"""
import argparse
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import os

def _require_api_key():
    key = os.environ.get("FTSHARE_API_KEY")
    if not key:
        print("FTSHARE_API_KEY environment variable is required", file=sys.stderr)
        raise SystemExit(2)
    return key


SAFE_URLOPENER = urllib.request.build_opener()

BASE_URL = os.environ.get("FTSHARE_BASE_URL", "https://market.ft.tech/gateway").rstrip("/")
_REQUEST_HEADERS = {"FTSHARE_API_KEY": os.environ["FTSHARE_API_KEY"], "Content-Type": "application/json"} if os.environ.get("FTSHARE_API_KEY") else {}
ENDPOINT = "/api/v1/market/data/stock-candlesticks"

INTERVAL_UNITS = ("Minute", "Day", "Week", "Month", "Year")
ADJUST_KINDS = ("None", "Forward", "Backward")


def safe_urlopen(req_or_url):
    if isinstance(req_or_url, urllib.request.Request):
        url = req_or_url.full_url
    else:
        url = str(req_or_url)
    parsed = urllib.parse.urlparse(url)
    base_parsed = urllib.parse.urlparse(BASE_URL)
    if parsed.scheme != base_parsed.scheme or parsed.netloc != base_parsed.netloc:
        print(f"Invalid URL for safe_urlopen: {url}", file=sys.stderr)
        sys.exit(1)
    if not isinstance(req_or_url, urllib.request.Request):
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    if isinstance(req_or_url, urllib.request.Request):
        for key, value in _REQUEST_HEADERS.items():
            req_or_url.add_unredirected_header(key, value)
    else:
        req_or_url = urllib.request.Request(str(req_or_url), headers=_REQUEST_HEADERS, method="GET")
    return SAFE_URLOPENER.open(req_or_url)


HEADERS = {
    "X-Client-Name": "ft-claw",
    "Content-Type": "application/json",
}


def build_body(symbol, interval_unit, interval_value, adjust_kind,
               since_ts_millis, until_ts_millis, limit):
    body = {
        "symbol": symbol,
        "interval_unit": interval_unit,
        "until_ts_millis": until_ts_millis,
    }
    if interval_value is not None and interval_value != 1:
        body["interval_value"] = interval_value
    if adjust_kind and adjust_kind != "None":
        body["adjust_kind"] = adjust_kind
    if since_ts_millis is not None:
        body["since_ts_millis"] = since_ts_millis
    if limit is not None:
        body["limit"] = limit
    return body


def fetch(
symbol, interval_unit, interval_value, adjust_kind,
          since_ts_millis, until_ts_millis, limit):
    body = build_body(symbol, interval_unit, interval_value, adjust_kind,
                      since_ts_millis, until_ts_millis, limit)
    query = urllib.parse.urlencode(body, doseq=True)
    url = f"{BASE_URL}{ENDPOINT}?{query}"
    req = urllib.request.Request(
        url,
        headers={**HEADERS, **_REQUEST_HEADERS},
        method="GET",
    )
    try:
        with safe_urlopen(req) as resp:
            return json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:
        msg = e.read().decode()
        print(f"HTTP {e.code}: {msg}", file=sys.stderr)
        sys.exit(1)
    except urllib.error.URLError as e:
        print(f"Request failed: {e}", file=sys.stderr)
        sys.exit(1)


def main():
    _require_api_key()
    parser = argparse.ArgumentParser(description="查询单只标的 K 线（GET 查询参数）")
    parser.add_argument("--symbol", required=True, help="标的代码，如 600519.SH、000001.SZ、510300.XSHG")
    parser.add_argument("--interval-unit", dest="interval_unit", required=True,
                        choices=INTERVAL_UNITS, help="K 线周期：Minute/Day/Week/Month/Year")
    parser.add_argument("--interval-value", dest="interval_value", type=int, default=1,
                        help="间隔数值，默认 1（Minute+5 表示 5 分钟 K）")
    parser.add_argument("--adjust-kind", dest="adjust_kind", default="None",
                        choices=ADJUST_KINDS, help="复权：None（默认）/Forward/Backward")
    parser.add_argument("--since-ts-millis", dest="since_ts_millis", type=int, default=None,
                        help="开始时间戳（毫秒）；分钟 K 与 until 跨度 ≤3 天")
    parser.add_argument("--until-ts-millis", dest="until_ts_millis", required=True, type=int,
                        help="结束时间戳（毫秒）")
    parser.add_argument("--limit", type=int, default=None, help="返回条数上限")
    args = parser.parse_args()

    data = fetch(args.symbol, args.interval_unit, args.interval_value,
                 args.adjust_kind, args.since_ts_millis, args.until_ts_millis, args.limit)
    print(json.dumps(data, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Tests for stock-candlesticks handler"""
import json
import sys
import unittest
import urllib.error
from io import BytesIO, StringIO
from unittest.mock import patch
import importlib.util
import os

_dir = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("handler", os.path.join(_dir, "handler.py"))
handler = importlib.util.module_from_spec(spec)


class TestBuildBody(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_required_fields(self):
        b = handler.build_body("600519.SH", "Day", 1, "None", None, 1756791000000, None)
        self.assertEqual(b["symbol"], "600519.SH")
        self.assertEqual(b["interval_unit"], "Day")
        self.assertEqual(b["until_ts_millis"], 1756791000000)
        self.assertNotIn("interval_value", b)

    def test_optional_fields(self):
        b = handler.build_body("000001.SZ", "Minute", 5, "Forward",
                               1756700000000, 1756791000000, 100)
        self.assertEqual(b["interval_value"], 5)
        self.assertEqual(b["adjust_kind"], "Forward")
        self.assertEqual(b["limit"], 100)


class TestFetch(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_get_to_stock_endpoint(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = b"[]"
        handler.fetch("600519.SH", "Day", 1, "None", None, 1756791000000, 5)
        req = mock_open.call_args[0][0]
        self.assertEqual(req.get_method(), "GET")
        self.assertIn("/api/v1/market/data/stock-candlesticks", req.full_url)
        self.assertIsNone(req.data)
        self.assertIn("symbol=600519.SH", req.full_url)
        self.assertEqual(req.headers.get("X-client-name"), "ft-claw")

    @patch.object(handler, "safe_urlopen")
    def test_http_error_exits(self, mock_open):
        mock_open.side_effect = urllib.error.HTTPError(
            "https://fake", 500, "Internal Error", {}, BytesIO(b"server error")
        )
        with self.assertRaises(SystemExit):
            handler.fetch("600519.SH", "Day", 1, "None", None, 1756791000000, None)


class TestMain(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    @patch.object(handler, "safe_urlopen")
    def test_main_emits_json(self, mock_open):
        mock_open.return_value.__enter__.return_value.read.return_value = (
            b'[{"open":"10.5","high":"10.6","low":"10.4","close":"10.55",'
            b'"ts_millis":1756710000000,"ts_millis_open":1756690200000,'
            b'"turnover":"100","volume":1000}]'
        )
        with patch.object(sys, "argv", [
            "handler.py", "--symbol", "600519.SH", "--interval-unit", "Day",
            "--until-ts-millis", "1756791000000"
        ]):
            with patch("sys.stdout", new_callable=StringIO) as fake_out:
                handler.main()
                data = json.loads(fake_out.getvalue())
                self.assertEqual(data[0]["close"], "10.55")


class TestSafeUrlopen(unittest.TestCase):
    def setUp(self):
        spec.loader.exec_module(handler)

    def test_rejects_wrong_host(self):
        with self.assertRaises(SystemExit):
            handler.safe_urlopen("https://evil.com/api")


if __name__ == "__main__":
    unittest.main()