"""固定策略函数的隐藏输入隔离；只补丁已列举查找点，不是安全沙箱。"""
import json
import os
import random
import time
import urllib.request
from unittest.mock import patch


def model_call():
    raise RuntimeError('合成模型哨兵，不连接模型')


def pure(closes):
    return [int(i >= 2 and x > sum(closes[i-2:i+1])/3) for i, x in enumerate(closes)]


def clock_dependent(closes):
    return [int(time.time() % 2 >= 1)] * len(closes)


def random_dependent(closes):
    return [int(random.random() > .5) for _ in closes]


def env_dependent(closes):
    return [int(os.getenv('R581_ONLY_FIXTURE', '0'))] * len(closes)


def network_dependent(closes):
    urllib.request.urlopen('https://example.invalid')
    return pure(closes)


def model_dependent(closes):
    model_call()
    return pure(closes)


xs = [10, 10, 12]
with patch('time.time', side_effect=RuntimeError('clock blocked')) as clock, \
     patch('random.random', side_effect=RuntimeError('random blocked')) as rng, \
     patch('os.getenv', side_effect=RuntimeError('env blocked')) as env, \
     patch('urllib.request.urlopen', side_effect=RuntimeError('network blocked')) as net, \
     patch(__name__ + '.model_call', side_effect=RuntimeError('model blocked')) as model:
    assert pure(xs) == pure(xs) == [0, 0, 1]
    for mock in [clock, rng, env, net, model]:
        mock.assert_not_called()
    rejected = []
    for fn in [clock_dependent, random_dependent, env_dependent, network_dependent, model_dependent]:
        try:
            fn(xs)
        except RuntimeError as error:
            rejected.append([fn.__name__, str(error)])
    assert len(rejected) == 5
    assert rejected == [['clock_dependent', 'clock blocked'],
                        ['random_dependent', 'random blocked'],
                        ['env_dependent', 'env blocked'],
                        ['network_dependent', 'network blocked'],
                        ['model_dependent', 'model blocked']]
    for mock in [clock, rng, env, net, model]:
        mock.assert_called_once()
with patch('time.time', return_value=0):
    first = clock_dependent(xs)
with patch('time.time', return_value=1):
    second = clock_dependent(xs)
assert first != second
def seeded():
    local = random.Random(7)
    return [local.random() for _ in range(3)]


seeded_one, seeded_two = seeded(), seeded()
assert seeded_one == seeded_two
assert len(set(seeded_one)) > 1
print(json.dumps({'pure_signals': pure(xs), 'forbidden_calls_detected': rejected,
                  'clock_outputs': [first, second], 'seeded_equal': True,
                  'scope': 'enumerated function dependencies only; no actual network/model call'}))